diff --git a/README.md b/README.md
index 234e07629..86cff25c5 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,44 @@ make build
 </script>
 ```
 
+## Abstract Syntax Tree
+
+#### Overview
+
+#### Anatomy of a Block
+```json
+{
+    "id": "^1r~63Gdl7;Dh?I*OP3_",
+    "opcode": "wedo_motorclockwise",
+    "next": null,
+    "fields": {
+        "DURATION": {
+            "name": "DURATION",
+            "value": null,
+            "blocks": {
+                "1?P=eV(OiDY3vMk!24Ip": {
+                    "id": "1?P=eV(OiDY3vMk!24Ip",
+                    "opcode": "math_number",
+                    "next": null,
+                    "fields": {
+                        "NUM": {
+                            "name": "NUM",
+                            "value": "10",
+                            "blocks": null
+                        }
+                    }
+                }
+            }
+        },
+        "SUBSTACK": {
+            "name": "SUBSTACK",
+            "value": "@1ln(HsUO4!]*2*%BrE|",
+            "blocks": null
+        }
+    }
+}
+```
+
 ## Testing
 ```bash
 make test
diff --git a/package.json b/package.json
index 90f5105db..3fd3d7539 100644
--- a/package.json
+++ b/package.json
@@ -13,10 +13,14 @@
   "scripts": {
     "test": "make test"
   },
-  "dependencies": {},
+  "dependencies": {
+    "htmlparser2": "3.9.0",
+    "memoizee": "0.3.10"
+  },
   "devDependencies": {
     "benchmark": "2.1.0",
     "eslint": "2.7.0",
+    "json-loader": "0.5.4",
     "tap": "5.7.1",
     "webpack": "1.13.0"
   }
diff --git a/src/engine/adapter.js b/src/engine/adapter.js
new file mode 100644
index 000000000..50240ca4e
--- /dev/null
+++ b/src/engine/adapter.js
@@ -0,0 +1,87 @@
+var html = require('htmlparser2');
+var memoize = require('memoizee');
+var parseDOM = memoize(html.parseDOM, {
+    length: 1,
+    resolvers: [String],
+    max: 200
+});
+
+/**
+ * Adapter between block creation events and block representation which can be
+ * used by the Scratch runtime.
+ *
+ * @param {Object} `Blockly.events.create`
+ *
+ * @return {Object}
+ */
+module.exports = function (e) {
+    // Validate input
+    if (typeof e !== 'object') return;
+    if (typeof e.blockId !== 'string') return;
+    if (typeof e.xml !== 'object') return;
+
+    // Storage object
+    var obj = {
+        id: e.blockId,
+        opcode: null,
+        next: null,
+        fields: {}
+    };
+
+    // Set opcode
+    if (typeof e.xml.attributes === 'object') {
+        obj.opcode = e.xml.attributes.type.value;
+    }
+
+    // Extract fields from event's `innerHTML`
+    if (typeof e.xml.innerHTML !== 'string') return obj;
+    if (e.xml.innerHTML === '') return obj;
+    obj.fields = extract(parseDOM(e.xml.innerHTML));
+
+    return obj;
+}
+
+/**
+ * Extracts fields from a block's innerHTML.
+ * @todo Extend this to support vertical grammar / nested blocks.
+ *
+ * @param {Object} DOM representation of block's innerHTML
+ *
+ * @return {Object}
+ */
+function extract (dom) {
+    // Storage object
+    var fields = {};
+
+    // Field
+    var field = dom[0];
+    var fieldName = field.attribs.name;
+    fields[fieldName] = {
+        name: fieldName,
+        value: null,
+        blocks: {}
+    };
+
+    // Shadow block
+    var shadow = field.children[0];
+    var shadowId = shadow.attribs.id;
+    var shadowOpcode = shadow.attribs.type;
+    fields[fieldName].blocks[shadowId] = {
+        id: shadowId,
+        opcode: shadowOpcode,
+        next: null,
+        fields: {}
+    };
+
+    // Primitive
+    var primitive = shadow.children[0];
+    var primitiveName = primitive.attribs.name;
+    var primitiveValue = primitive.children[0].data;
+    fields[fieldName].blocks[shadowId].fields[primitiveName] = {
+        name: primitiveName,
+        value: primitiveValue,
+        blocks: null
+    };
+
+    return fields;
+}
diff --git a/src/engine/primatives.js b/src/engine/primatives.js
index c8ee6c193..3e8fb2dae 100644
--- a/src/engine/primatives.js
+++ b/src/engine/primatives.js
@@ -1,41 +1,5 @@
 function Primitives () {
-
+    // @todo
 }
 
-Primitives.prototype.event_whenflagclicked = function (thread, runtime) {
-    // No-op: flags are started by the interpreter but don't do any action
-    // Take 1/3 second to show running state
-    if (Date.now() - thread.blockFirstTime < 300) {
-        thread.yield = true;
-        return;
-    }
-};
-
-Primitives.prototype.control_repeat = function (thread, runtime) {
-    // Take 1/3 second to show running state
-    if (Date.now() - thread.blockFirstTime < 300) {
-        thread.yield = true;
-        return;
-    }
-    if (thread.repeatCounter == -1) {
-        thread.repeatCounter = 10; // @todo from the arg
-    }
-    if (thread.repeatCounter > 0) {
-        thread.repeatCounter -= 1;
-        runtime.interpreter.startSubstack(thread);
-    } else {
-        thread.repeatCounter = -1;
-        thread.nextBlock = runtime.getNextBlock(thread.blockPointer);
-    }
-};
-
-Primitives.prototype.control_forever = function (thread, runtime) {
-    // Take 1/3 second to show running state
-    if (Date.now() - thread.blockFirstTime < 300) {
-        thread.yield = true;
-        return;
-    }
-    runtime.interpreter.startSubstack(thread);
-};
-
 module.exports = Primitives;
diff --git a/src/engine/runtime.js b/src/engine/runtime.js
index 6625fa465..4c81faab6 100644
--- a/src/engine/runtime.js
+++ b/src/engine/runtime.js
@@ -1,26 +1,19 @@
 var EventEmitter = require('events');
 var util = require('util');
 
-var Primitives = require('./primatives');
-var Sequencer = require('./sequencer');
-var Thread = require('./thread');
-
-var STEP_THREADS_INTERVAL = 1000 / 30;
-
 /**
  * A simple runtime for blocks.
  */
 function Runtime () {
     // Bind event emitter
-    EventEmitter.call(instance);
-
-    // Instantiate sequencer and primitives
-    this.sequencer = new Sequencer(this);
-    this.primitives = new Primitives();
+    EventEmitter.call(this);
 
     // State
     this.blocks = {};
     this.stacks = [];
+
+    window._BLOCKS = this.blocks;
+    window._STACKS = this.stacks;
 }
 
 /**
@@ -28,19 +21,34 @@ function Runtime () {
  */
 util.inherits(Runtime, EventEmitter);
 
-Runtime.prototype.createBlock = function (e) {
+Runtime.prototype.createBlock = function (block) {
     // Create new block
-    this.blocks[e.id] = {
-        id: e.id,
-        opcode: e.opcode,
-        next: null,
-        inputs: {}
-    };
+    this.blocks[block.id] = block;
+
+    // Walk each field and add any shadow blocks
+    // @todo Expand this to cover vertical / nested blocks
+    for (var i in block.fields) {
+        var shadows = block.fields[i].blocks;
+        for (var y in shadows) {
+            var shadow = shadows[y];
+            this.blocks[shadow.id] = shadow;
+        };
+    }
 
     // Push block id to stacks array. New blocks are always a stack even if only
     // momentary. If the new block is added to an existing stack this stack will
     // be removed by the `moveBlock` method below.
-    this.stacks.push(e.id);
+    this.stacks.push(block.id);
+};
+
+Runtime.prototype.changeBlock = function (args) {
+    // Validate
+    if (args.element !== 'field') return;
+    if (typeof this.blocks[args.id] === 'undefined') return;
+    if (typeof this.blocks[args.id].fields[args.name] === 'undefined') return;
+
+    // Update block value
+    this.blocks[args.id].fields[args.name].value = args.value;
 };
 
 Runtime.prototype.moveBlock = function (e) {
@@ -52,10 +60,14 @@ Runtime.prototype.moveBlock = function (e) {
         _this._deleteStack(e.id);
 
         // Update new parent
-        if (e.newInput === undefined) {
+        if (e.newField === undefined) {
             _this.blocks[e.newParent].next = e.id;
         } else {
-            _this.blocks[e.newParent].inputs[e.newInput] = e.id;
+            _this.blocks[e.newParent].fields[e.newField] = {
+                name: e.newField,
+                value: e.id,
+                blocks: {}
+            };
         }
     }
 
@@ -65,30 +77,34 @@ Runtime.prototype.moveBlock = function (e) {
         _this.stacks.push(e.id);
 
         // Update old parent
-        if (e.oldInput === undefined) {
+        if (e.oldField === undefined) {
             _this.blocks[e.oldParent].next = null;
         } else {
-            delete _this.blocks[e.oldParent].inputs[e.oldInput];
+            delete _this.blocks[e.oldParent].fields[e.oldField];
         }
     }
 };
 
-Runtime.prototype.changeBlock = function (e) {
-    // @todo
-};
-
 Runtime.prototype.deleteBlock = function (e) {
     // @todo Stop threads running on this stack
 
-    // Delete children
+    // Get block
     var block = this.blocks[e.id];
+
+    // Delete children
     if (block.next !== null) {
         this.deleteBlock({id: block.next});
     }
 
-    // Delete inputs
-    for (var i in block.inputs) {
-        this.deleteBlock({id: block.inputs[i]});
+    // Delete substacks and fields
+    for (var field in block.fields) {
+        if (field === 'SUBSTACK') {
+            this.deleteBlock({id: block.fields[field].value});
+        } else {
+            for (var shadow in block.fields[field].blocks) {
+                this.deleteBlock({id: shadow});
+            }
+        }
     }
 
     // Delete stack
@@ -98,19 +114,6 @@ Runtime.prototype.deleteBlock = function (e) {
     delete this.blocks[e.id];
 };
 
-Runtime.prototype.runAllStacks = function () {
-    // @todo
-};
-
-Runtime.prototype.runStack = function (e) {
-    // @todo
-    console.dir(e);
-};
-
-Runtime.prototype.stopAllStacks = function () {
-    // @todo
-};
-
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
@@ -126,7 +129,7 @@ Runtime.prototype._getNextBlock = function (id) {
 
 Runtime.prototype._getSubstack = function (id) {
     if (typeof this.blocks[id] === 'undefined') return null;
-    return this.blocks[id].inputs['SUBSTACK'];
+    return this.blocks[id].fields['SUBSTACK'];
 };
 
 module.exports = Runtime;
diff --git a/src/engine/sequencer.js b/src/engine/sequencer.js
index 09723614f..919f105fa 100644
--- a/src/engine/sequencer.js
+++ b/src/engine/sequencer.js
@@ -1,29 +1,5 @@
-var Timer = require('../util/timer');
-
-/**
- * Constructor
- */
-function Sequencer (runtime) {
-    // Bi-directional binding for runtime
-    this.runtime = runtime;
-
-    // State
-    this.runningThreads = [];
-    this.workTime = 30;
-    this.timer = new Timer();
-    this.currentTime = 0;
+function Sequencer () {
+    // @todo
 }
 
-Sequencer.prototype.stepAllThreads = function () {
-
-};
-
-Sequencer.prototype.stepThread = function (thread) {
-
-};
-
-Sequencer.prototype.startSubstack = function (thread) {
-
-};
-
 module.exports = Sequencer;
diff --git a/src/engine/thread.js b/src/engine/thread.js
index a3ce684ab..42dd09587 100644
--- a/src/engine/thread.js
+++ b/src/engine/thread.js
@@ -1,19 +1,5 @@
-/**
- * Thread is an internal data structure used by the interpreter. It holds the
- * state of a thread so it can continue from where it left off, and it has
- * a stack to support nested control structures and procedure calls.
- *
- * @param {String} Unique block identifier
- */
-function Thread (id) {
-    this.topBlockId = id;
-    this.blockPointer = id;
-    this.blockFirstTime = -1;
-    this.nextBlock = null;
-    this.waiting = null;
-    this.runningDeviceBlock = false;
-    this.stack = [];
-    this.repeatCounter = -1;
+function Thread () {
+    // @todo
 }
 
 module.exports = Thread;
diff --git a/src/index.js b/src/index.js
index 148155b51..d88033341 100644
--- a/src/index.js
+++ b/src/index.js
@@ -2,6 +2,7 @@ var EventEmitter = require('events');
 var util = require('util');
 
 var Runtime = require('./engine/runtime');
+var adapter = require('./engine/adapter');
 
 /**
  * Handles connections between blocks, stage, and extensions.
@@ -30,23 +31,23 @@ function VirtualMachine () {
         // Blocks
         switch (e.type) {
         case 'create':
-            instance.runtime.createBlock({
+            instance.runtime.createBlock(adapter(e));
+            break;
+        case 'change':
+            instance.runtime.changeBlock({
                 id: e.blockId,
-                opcode: e.xml.attributes.type.value
+                element: e.element,
+                name: e.name,
+                value: e.newValue
             });
             break;
         case 'move':
             instance.runtime.moveBlock({
                 id: e.blockId,
                 oldParent: e.oldParentId,
-                oldInput: e.oldInputName,
+                oldField: e.oldInputName,
                 newParent: e.newParentId,
-                newInput: e.newInputName
-            });
-            break;
-        case 'change':
-            instance.runtime.changeBlock({
-                id: e.blockId
+                newField: e.newInputName
             });
             break;
         case 'delete':
@@ -55,19 +56,7 @@ function VirtualMachine () {
             });
             break;
         }
-
-        // UI
-        if (typeof e.element === 'undefined') return;
-        switch (e.element) {
-        case 'click':
-            instance.runtime.runStack({
-                id: e.blockId
-            });
-            break;
-        }
     };
-
-    // @todo Forward runtime events
 }
 
 /**
@@ -75,22 +64,6 @@ function VirtualMachine () {
  */
 util.inherits(VirtualMachine, EventEmitter);
 
-VirtualMachine.prototype.start = function () {
-    // @todo Run all green flags
-};
-
-VirtualMachine.prototype.stop = function () {
-    // @todo Stop all threads
-};
-
-VirtualMachine.prototype.save = function () {
-    // @todo Serialize runtime state
-};
-
-VirtualMachine.prototype.load = function () {
-    // @todo Deserialize and apply runtime state
-};
-
 /**
  * Export and bind to `window`
  */
diff --git a/src/util/timer.js b/src/util/timer.js
index f093c3e53..b16585205 100644
--- a/src/util/timer.js
+++ b/src/util/timer.js
@@ -1,6 +1,5 @@
 /**
  * Constructor
- * @todo Swap out Date.now() with microtime module that works in node & browsers
  */
 function Timer () {
     this.startTime = 0;
diff --git a/test/benchmark/ast.js b/test/benchmark/ast.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/test/fixtures/blocks.js b/test/fixtures/blocks.js
deleted file mode 100644
index 0b5c396b0..000000000
--- a/test/fixtures/blocks.js
+++ /dev/null
@@ -1,26 +0,0 @@
-var events = require('events');
-var util = require('util');
-
-/**
- * Simulates event emitter / listener patterns from Scratch Blocks.
- *
- * @author Andrew Sliwinski <ascii@media.mit.edu>
- */
-function Blocks () {
-
-}
-
-/**
- * Inherit from EventEmitter to enable messaging.
- */
-util.inherits(VirtualMachine, events.EventEmitter);
-
-Blocks.prototype.spaghetti = function () {
-    this.emit('');
-};
-
-Blocks.prototype.spam = function () {
-    this.emit('');
-};
-
-module.exports = Blocks;
diff --git a/test/fixtures/events.json b/test/fixtures/events.json
new file mode 100644
index 000000000..fca8693ff
--- /dev/null
+++ b/test/fixtures/events.json
@@ -0,0 +1,20 @@
+{
+    "create": {
+        "blockId": "z!+#Nqr,_(V=xz0y7a@d",
+        "workspaceId": "7Luws3lyb*Z98~Kk+IG|",
+        "group": ";OswyM#@%`%,xOrhOXC=",
+        "recordUndo": true,
+        "xml": {
+            "attributes": {
+                "type": {
+                    "value": "wedo_motorclockwise"
+                }
+            },
+            "innerHTML": "<value name=\"DURATION\"><shadow type=\"math_number\" id=\"!6Ahqg4f}Ljl}X5Hws?Z\"><field name=\"NUM\">10</field></shadow></value>"
+        },
+        "ids": [
+            "z!+#Nqr,_(V=xz0y7a@d",
+            "!6Ahqg4f}Ljl}X5Hws?Z"
+        ]
+    }
+}
diff --git a/test/integration/index.js b/test/integration/index.js
new file mode 100644
index 000000000..c91a852f8
--- /dev/null
+++ b/test/integration/index.js
@@ -0,0 +1,22 @@
+var test = require('tap').test;
+var VirtualMachine = require('../../src/index');
+
+test('spec', function (t) {
+    t.end();
+});
+
+test('create', function (t) {
+    t.end();
+});
+
+test('move', function (t) {
+    t.end();
+});
+
+test('change', function (t) {
+    t.end();
+});
+
+test('delete', function (t) {
+    t.end();
+});
diff --git a/test/unit/adapter.js b/test/unit/adapter.js
new file mode 100644
index 000000000..547e0b9b0
--- /dev/null
+++ b/test/unit/adapter.js
@@ -0,0 +1,20 @@
+var test = require('tap').test;
+var adapter = require('../../src/engine/adapter');
+var events = require('../fixtures/events.json');
+
+test('spec', function (t) {
+    t.type(adapter, 'function');
+    t.end();
+});
+
+test('create event', function (t) {
+    var result = adapter(events.create);
+
+    t.type(result, 'object');
+    t.type(result.id, 'string');
+    t.type(result.opcode, 'string');
+    t.type(result.fields, 'object');
+    t.type(result.fields['DURATION'], 'object');
+
+    t.end();
+});
diff --git a/test/unit/primatives.js b/test/unit/primatives.js
new file mode 100644
index 000000000..c028dc2f5
--- /dev/null
+++ b/test/unit/primatives.js
@@ -0,0 +1,8 @@
+var test = require('tap').test;
+var Primatives = require('../../src/engine/primatives');
+
+test('spec', function (t) {
+    t.type(Primatives, 'function');
+    // @todo
+    t.end();
+});
diff --git a/test/unit/runtime.js b/test/unit/runtime.js
index ac58d4e6b..0e41ed5be 100644
--- a/test/unit/runtime.js
+++ b/test/unit/runtime.js
@@ -24,7 +24,9 @@ test('create', function (t) {
     var r = new Runtime();
     r.createBlock({
         id: 'foo',
-        opcode: 'TEST_BLOCK'
+        opcode: 'TEST_BLOCK',
+        next: null,
+        fields: {}
     });
 
     t.type(r.blocks['foo'], 'object');
@@ -37,11 +39,15 @@ test('move', function (t) {
     var r = new Runtime();
     r.createBlock({
         id: 'foo',
-        opcode: 'TEST_BLOCK'
+        opcode: 'TEST_BLOCK',
+        next: null,
+        fields: {}
     });
     r.createBlock({
         id: 'bar',
-        opcode: 'TEST_BLOCK'
+        opcode: 'TEST_BLOCK',
+        next: null,
+        fields: {}
     });
 
     // Attach 'bar' to the end of 'foo'
@@ -69,7 +75,9 @@ test('delete', function (t) {
     var r = new Runtime();
     r.createBlock({
         id: 'foo',
-        opcode: 'TEST_BLOCK'
+        opcode: 'TEST_BLOCK',
+        next: null,
+        fields: {}
     });
     r.deleteBlock({
         id: 'foo'
diff --git a/test/unit/sequencer.js b/test/unit/sequencer.js
new file mode 100644
index 000000000..23ec4c13d
--- /dev/null
+++ b/test/unit/sequencer.js
@@ -0,0 +1,8 @@
+var test = require('tap').test;
+var Sequencer = require('../../src/engine/sequencer');
+
+test('spec', function (t) {
+    t.type(Sequencer, 'function');
+    // @todo
+    t.end();
+});
diff --git a/test/unit/spec.js b/test/unit/spec.js
index 796c165fe..22519faa7 100644
--- a/test/unit/spec.js
+++ b/test/unit/spec.js
@@ -2,17 +2,10 @@ var test = require('tap').test;
 var VirtualMachine = require('../../src/index');
 
 test('spec', function (t) {
-    var vm = new VirtualMachine('foo');
+    var vm = new VirtualMachine();
 
     t.type(VirtualMachine, 'function');
     t.type(vm, 'object');
-
     t.type(vm.blockListener, 'function');
-    // t.type(vm.uiListener, 'function');
-    // t.type(vm.start, 'function');
-    // t.type(vm.stop, 'function');
-    // t.type(vm.save, 'function');
-    // t.type(vm.load, 'function');
-
     t.end();
 });
diff --git a/test/unit/thread.js b/test/unit/thread.js
index 3e5cede60..3bda4fc69 100644
--- a/test/unit/thread.js
+++ b/test/unit/thread.js
@@ -2,9 +2,7 @@ var test = require('tap').test;
 var Thread = require('../../src/engine/thread');
 
 test('spec', function (t) {
-    var thread = new Thread('foo');
-
     t.type(Thread, 'function');
-    t.type(thread, 'object');
+    // @todo
     t.end();
 });
diff --git a/vm.js b/vm.js
index c91db8ad5..5358a9e4c 100644
--- a/vm.js
+++ b/vm.js
@@ -48,6 +48,7 @@
 	var util = __webpack_require__(2);
 
 	var Runtime = __webpack_require__(6);
+	var adapter = __webpack_require__(7);
 
 	/**
 	 * Handles connections between blocks, stage, and extensions.
@@ -76,23 +77,23 @@
 	        // Blocks
 	        switch (e.type) {
 	        case 'create':
-	            instance.runtime.createBlock({
+	            instance.runtime.createBlock(adapter(e));
+	            break;
+	        case 'change':
+	            instance.runtime.changeBlock({
 	                id: e.blockId,
-	                opcode: e.xml.attributes.type.value
+	                element: e.element,
+	                name: e.name,
+	                value: e.newValue
 	            });
 	            break;
 	        case 'move':
 	            instance.runtime.moveBlock({
 	                id: e.blockId,
 	                oldParent: e.oldParentId,
-	                oldInput: e.oldInputName,
+	                oldField: e.oldInputName,
 	                newParent: e.newParentId,
-	                newInput: e.newInputName
-	            });
-	            break;
-	        case 'change':
-	            instance.runtime.changeBlock({
-	                id: e.blockId
+	                newField: e.newInputName
 	            });
 	            break;
 	        case 'delete':
@@ -101,19 +102,7 @@
 	            });
 	            break;
 	        }
-
-	        // UI
-	        if (typeof e.element === 'undefined') return;
-	        switch (e.element) {
-	        case 'click':
-	            instance.runtime.runStack({
-	                id: e.blockId
-	            });
-	            break;
-	        }
 	    };
-
-	    // @todo Forward runtime events
 	}
 
 	/**
@@ -121,22 +110,6 @@
 	 */
 	util.inherits(VirtualMachine, EventEmitter);
 
-	VirtualMachine.prototype.start = function () {
-	    // @todo Run all green flags
-	};
-
-	VirtualMachine.prototype.stop = function () {
-	    // @todo Stop all threads
-	};
-
-	VirtualMachine.prototype.save = function () {
-	    // @todo Serialize runtime state
-	};
-
-	VirtualMachine.prototype.load = function () {
-	    // @todo Deserialize and apply runtime state
-	};
-
 	/**
 	 * Export and bind to `window`
 	 */
@@ -1185,26 +1158,19 @@
 	var EventEmitter = __webpack_require__(1);
 	var util = __webpack_require__(2);
 
-	var Primitives = __webpack_require__(7);
-	var Sequencer = __webpack_require__(8);
-	var Thread = __webpack_require__(10);
-
-	var STEP_THREADS_INTERVAL = 1000 / 30;
-
 	/**
 	 * A simple runtime for blocks.
 	 */
 	function Runtime () {
 	    // Bind event emitter
-	    EventEmitter.call(instance);
-
-	    // Instantiate sequencer and primitives
-	    this.sequencer = new Sequencer(this);
-	    this.primitives = new Primitives();
+	    EventEmitter.call(this);
 
 	    // State
 	    this.blocks = {};
 	    this.stacks = [];
+
+	    window._BLOCKS = this.blocks;
+	    window._STACKS = this.stacks;
 	}
 
 	/**
@@ -1212,19 +1178,34 @@
 	 */
 	util.inherits(Runtime, EventEmitter);
 
-	Runtime.prototype.createBlock = function (e) {
+	Runtime.prototype.createBlock = function (block) {
 	    // Create new block
-	    this.blocks[e.id] = {
-	        id: e.id,
-	        opcode: e.opcode,
-	        next: null,
-	        inputs: {}
-	    };
+	    this.blocks[block.id] = block;
+
+	    // Walk each field and add any shadow blocks
+	    // @todo Expand this to cover vertical / nested blocks
+	    for (var i in block.fields) {
+	        var shadows = block.fields[i].blocks;
+	        for (var y in shadows) {
+	            var shadow = shadows[y];
+	            this.blocks[shadow.id] = shadow;
+	        };
+	    }
 
 	    // Push block id to stacks array. New blocks are always a stack even if only
 	    // momentary. If the new block is added to an existing stack this stack will
 	    // be removed by the `moveBlock` method below.
-	    this.stacks.push(e.id);
+	    this.stacks.push(block.id);
+	};
+
+	Runtime.prototype.changeBlock = function (args) {
+	    // Validate
+	    if (args.element !== 'field') return;
+	    if (typeof this.blocks[args.id] === 'undefined') return;
+	    if (typeof this.blocks[args.id].fields[args.name] === 'undefined') return;
+
+	    // Update block value
+	    this.blocks[args.id].fields[args.name].value = args.value;
 	};
 
 	Runtime.prototype.moveBlock = function (e) {
@@ -1236,10 +1217,14 @@
 	        _this._deleteStack(e.id);
 
 	        // Update new parent
-	        if (e.newInput === undefined) {
+	        if (e.newField === undefined) {
 	            _this.blocks[e.newParent].next = e.id;
 	        } else {
-	            _this.blocks[e.newParent].inputs[e.newInput] = e.id;
+	            _this.blocks[e.newParent].fields[e.newField] = {
+	                name: e.newField,
+	                value: e.id,
+	                blocks: {}
+	            };
 	        }
 	    }
 
@@ -1249,30 +1234,34 @@
 	        _this.stacks.push(e.id);
 
 	        // Update old parent
-	        if (e.oldInput === undefined) {
+	        if (e.oldField === undefined) {
 	            _this.blocks[e.oldParent].next = null;
 	        } else {
-	            delete _this.blocks[e.oldParent].inputs[e.oldInput];
+	            delete _this.blocks[e.oldParent].fields[e.oldField];
 	        }
 	    }
 	};
 
-	Runtime.prototype.changeBlock = function (e) {
-	    // @todo
-	};
-
 	Runtime.prototype.deleteBlock = function (e) {
 	    // @todo Stop threads running on this stack
 
-	    // Delete children
+	    // Get block
 	    var block = this.blocks[e.id];
+
+	    // Delete children
 	    if (block.next !== null) {
 	        this.deleteBlock({id: block.next});
 	    }
 
-	    // Delete inputs
-	    for (var i in block.inputs) {
-	        this.deleteBlock({id: block.inputs[i]});
+	    // Delete substacks and fields
+	    for (var field in block.fields) {
+	        if (field === 'SUBSTACK') {
+	            this.deleteBlock({id: block.fields[field].value});
+	        } else {
+	            for (var shadow in block.fields[field].blocks) {
+	                this.deleteBlock({id: shadow});
+	            }
+	        }
 	    }
 
 	    // Delete stack
@@ -1282,19 +1271,6 @@
 	    delete this.blocks[e.id];
 	};
 
-	Runtime.prototype.runAllStacks = function () {
-	    // @todo
-	};
-
-	Runtime.prototype.runStack = function (e) {
-	    // @todo
-	    console.dir(e);
-	};
-
-	Runtime.prototype.stopAllStacks = function () {
-	    // @todo
-	};
-
 	// -----------------------------------------------------------------------------
 	// -----------------------------------------------------------------------------
 
@@ -1310,7 +1286,7 @@
 
 	Runtime.prototype._getSubstack = function (id) {
 	    if (typeof this.blocks[id] === 'undefined') return null;
-	    return this.blocks[id].inputs['SUBSTACK'];
+	    return this.blocks[id].fields['SUBSTACK'];
 	};
 
 	module.exports = Runtime;
@@ -1318,136 +1294,11535 @@
 
 /***/ },
 /* 7 */
-/***/ function(module, exports) {
+/***/ function(module, exports, __webpack_require__) {
 
-	function Primitives () {
+	var html = __webpack_require__(8);
+	var memoize = __webpack_require__(59);
+	var parseDOM = memoize(html.parseDOM, {
+	    length: 1,
+	    resolvers: [String],
+	    max: 200
+	});
 
+	/**
+	 * Adapter between block creation events and block representation which can be
+	 * used by the Scratch runtime.
+	 *
+	 * @param {Object} `Blockly.events.create`
+	 *
+	 * @return {Object}
+	 */
+	module.exports = function (e) {
+	    // Validate input
+	    if (typeof e !== 'object') return;
+	    if (typeof e.blockId !== 'string') return;
+	    if (typeof e.xml !== 'object') return;
+
+	    // Storage object
+	    var obj = {
+	        id: e.blockId,
+	        opcode: null,
+	        next: null,
+	        fields: {}
+	    };
+
+	    // Set opcode
+	    if (typeof e.xml.attributes === 'object') {
+	        obj.opcode = e.xml.attributes.type.value;
+	    }
+
+	    // Extract fields from event's `innerHTML`
+	    if (typeof e.xml.innerHTML !== 'string') return obj;
+	    if (e.xml.innerHTML === '') return obj;
+	    obj.fields = extract(parseDOM(e.xml.innerHTML));
+
+	    return obj;
 	}
 
-	Primitives.prototype.event_whenflagclicked = function (thread, runtime) {
-	    // No-op: flags are started by the interpreter but don't do any action
-	    // Take 1/3 second to show running state
-	    if (Date.now() - thread.blockFirstTime < 300) {
-	        thread.yield = true;
-	        return;
-	    }
-	};
+	/**
+	 * Extracts fields from a block's innerHTML.
+	 * @todo Extend this to support vertical grammar / nested blocks.
+	 *
+	 * @param {Object} DOM representation of block's innerHTML
+	 *
+	 * @return {Object}
+	 */
+	function extract (dom) {
+	    // Storage object
+	    var fields = {};
 
-	Primitives.prototype.control_repeat = function (thread, runtime) {
-	    // Take 1/3 second to show running state
-	    if (Date.now() - thread.blockFirstTime < 300) {
-	        thread.yield = true;
-	        return;
-	    }
-	    if (thread.repeatCounter == -1) {
-	        thread.repeatCounter = 10; // @todo from the arg
-	    }
-	    if (thread.repeatCounter > 0) {
-	        thread.repeatCounter -= 1;
-	        runtime.interpreter.startSubstack(thread);
-	    } else {
-	        thread.repeatCounter = -1;
-	        thread.nextBlock = runtime.getNextBlock(thread.blockPointer);
-	    }
-	};
+	    // Field
+	    var field = dom[0];
+	    var fieldName = field.attribs.name;
+	    fields[fieldName] = {
+	        name: fieldName,
+	        value: null,
+	        blocks: {}
+	    };
 
-	Primitives.prototype.control_forever = function (thread, runtime) {
-	    // Take 1/3 second to show running state
-	    if (Date.now() - thread.blockFirstTime < 300) {
-	        thread.yield = true;
-	        return;
-	    }
-	    runtime.interpreter.startSubstack(thread);
-	};
+	    // Shadow block
+	    var shadow = field.children[0];
+	    var shadowId = shadow.attribs.id;
+	    var shadowOpcode = shadow.attribs.type;
+	    fields[fieldName].blocks[shadowId] = {
+	        id: shadowId,
+	        opcode: shadowOpcode,
+	        next: null,
+	        fields: {}
+	    };
 
-	module.exports = Primitives;
+	    // Primitive
+	    var primitive = shadow.children[0];
+	    var primitiveName = primitive.attribs.name;
+	    var primitiveValue = primitive.children[0].data;
+	    fields[fieldName].blocks[shadowId].fields[primitiveName] = {
+	        name: primitiveName,
+	        value: primitiveValue,
+	        blocks: null
+	    };
+
+	    return fields;
+	}
 
 
 /***/ },
 /* 8 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var Timer = __webpack_require__(9);
+	var Parser = __webpack_require__(9),
+	    DomHandler = __webpack_require__(16);
 
-	/**
-	 * Constructor
-	 */
-	function Sequencer (runtime) {
-	    // Bi-directional binding for runtime
-	    this.runtime = runtime;
-
-	    // State
-	    this.runningThreads = [];
-	    this.workTime = 30;
-	    this.timer = new Timer();
-	    this.currentTime = 0;
+	function defineProp(name, value){
+		delete module.exports[name];
+		module.exports[name] = value;
+		return value;
 	}
 
-	Sequencer.prototype.stepAllThreads = function () {
-
+	module.exports = {
+		Parser: Parser,
+		Tokenizer: __webpack_require__(10),
+		ElementType: __webpack_require__(17),
+		DomHandler: DomHandler,
+		get FeedHandler(){
+			return defineProp("FeedHandler", __webpack_require__(20));
+		},
+		get Stream(){
+			return defineProp("Stream", __webpack_require__(21));
+		},
+		get WritableStream(){
+			return defineProp("WritableStream", __webpack_require__(22));
+		},
+		get ProxyHandler(){
+			return defineProp("ProxyHandler", __webpack_require__(45));
+		},
+		get DomUtils(){
+			return defineProp("DomUtils", __webpack_require__(46));
+		},
+		get CollectingHandler(){
+			return defineProp("CollectingHandler", __webpack_require__(58));
+		},
+		// For legacy support
+		DefaultHandler: DomHandler,
+		get RssHandler(){
+			return defineProp("RssHandler", this.FeedHandler);
+		},
+		//helper methods
+		parseDOM: function(data, options){
+			var handler = new DomHandler(options);
+			new Parser(handler, options).end(data);
+			return handler.dom;
+		},
+		parseFeed: function(feed, options){
+			var handler = new module.exports.FeedHandler(options);
+			new Parser(handler, options).end(feed);
+			return handler.dom;
+		},
+		createDomStream: function(cb, options, elementCb){
+			var handler = new DomHandler(cb, options, elementCb);
+			return new Parser(handler, options);
+		},
+		// List of all events that the parser emits
+		EVENTS: { /* Format: eventname: number of arguments */
+			attribute: 2,
+			cdatastart: 0,
+			cdataend: 0,
+			text: 1,
+			processinginstruction: 2,
+			comment: 1,
+			commentend: 0,
+			closetag: 1,
+			opentag: 2,
+			opentagname: 1,
+			error: 1,
+			end: 0
+		}
 	};
 
-	Sequencer.prototype.stepThread = function (thread) {
-
-	};
-
-	Sequencer.prototype.startSubstack = function (thread) {
-
-	};
-
-	module.exports = Sequencer;
-
 
 /***/ },
 /* 9 */
-/***/ function(module, exports) {
+/***/ function(module, exports, __webpack_require__) {
 
-	/**
-	 * Constructor
-	 * @todo Swap out Date.now() with microtime module that works in node & browsers
-	 */
-	function Timer () {
-	    this.startTime = 0;
+	var Tokenizer = __webpack_require__(10);
+
+	/*
+		Options:
+
+		xmlMode: Disables the special behavior for script/style tags (false by default)
+		lowerCaseAttributeNames: call .toLowerCase for each attribute name (true if xmlMode is `false`)
+		lowerCaseTags: call .toLowerCase for each tag name (true if xmlMode is `false`)
+	*/
+
+	/*
+		Callbacks:
+
+		oncdataend,
+		oncdatastart,
+		onclosetag,
+		oncomment,
+		oncommentend,
+		onerror,
+		onopentag,
+		onprocessinginstruction,
+		onreset,
+		ontext
+	*/
+
+	var formTags = {
+		input: true,
+		option: true,
+		optgroup: true,
+		select: true,
+		button: true,
+		datalist: true,
+		textarea: true
+	};
+
+	var openImpliesClose = {
+		tr      : { tr:true, th:true, td:true },
+		th      : { th:true },
+		td      : { thead:true, th:true, td:true },
+		body    : { head:true, link:true, script:true },
+		li      : { li:true },
+		p       : { p:true },
+		h1      : { p:true },
+		h2      : { p:true },
+		h3      : { p:true },
+		h4      : { p:true },
+		h5      : { p:true },
+		h6      : { p:true },
+		select  : formTags,
+		input   : formTags,
+		output  : formTags,
+		button  : formTags,
+		datalist: formTags,
+		textarea: formTags,
+		option  : { option:true },
+		optgroup: { optgroup:true }
+	};
+
+	var voidElements = {
+		__proto__: null,
+		area: true,
+		base: true,
+		basefont: true,
+		br: true,
+		col: true,
+		command: true,
+		embed: true,
+		frame: true,
+		hr: true,
+		img: true,
+		input: true,
+		isindex: true,
+		keygen: true,
+		link: true,
+		meta: true,
+		param: true,
+		source: true,
+		track: true,
+		wbr: true,
+
+		//common self closing svg elements
+		path: true,
+		circle: true,
+		ellipse: true,
+		line: true,
+		rect: true,
+		use: true,
+		stop: true,
+		polyline: true,
+		polygon: true
+	};
+
+	var re_nameEnd = /\s|\//;
+
+	function Parser(cbs, options){
+		this._options = options || {};
+		this._cbs = cbs || {};
+
+		this._tagname = "";
+		this._attribname = "";
+		this._attribvalue = "";
+		this._attribs = null;
+		this._stack = [];
+
+		this.startIndex = 0;
+		this.endIndex = null;
+
+		this._lowerCaseTagNames = "lowerCaseTags" in this._options ?
+										!!this._options.lowerCaseTags :
+										!this._options.xmlMode;
+		this._lowerCaseAttributeNames = "lowerCaseAttributeNames" in this._options ?
+										!!this._options.lowerCaseAttributeNames :
+										!this._options.xmlMode;
+		if(!!this._options.Tokenizer) {
+			Tokenizer = this._options.Tokenizer;
+		}
+		this._tokenizer = new Tokenizer(this._options, this);
+
+		if(this._cbs.onparserinit) this._cbs.onparserinit(this);
 	}
 
-	Timer.prototype.time = function () {
-	    return Date.now();
+	__webpack_require__(2).inherits(Parser, __webpack_require__(1).EventEmitter);
+
+	Parser.prototype._updatePosition = function(initialOffset){
+		if(this.endIndex === null){
+			if(this._tokenizer._sectionStart <= initialOffset){
+				this.startIndex = 0;
+			} else {
+				this.startIndex = this._tokenizer._sectionStart - initialOffset;
+			}
+		}
+		else this.startIndex = this.endIndex + 1;
+		this.endIndex = this._tokenizer.getAbsoluteIndex();
 	};
 
-	Timer.prototype.start = function () {
-	    this.startTime = this.time();
+	//Tokenizer event handlers
+	Parser.prototype.ontext = function(data){
+		this._updatePosition(1);
+		this.endIndex--;
+
+		if(this._cbs.ontext) this._cbs.ontext(data);
 	};
 
-	Timer.prototype.stop = function () {
-	    return this.startTime - this.time();
+	Parser.prototype.onopentagname = function(name){
+		if(this._lowerCaseTagNames){
+			name = name.toLowerCase();
+		}
+
+		this._tagname = name;
+
+		if(!this._options.xmlMode && name in openImpliesClose) {
+			for(
+				var el;
+				(el = this._stack[this._stack.length - 1]) in openImpliesClose[name];
+				this.onclosetag(el)
+			);
+		}
+
+		if(this._options.xmlMode || !(name in voidElements)){
+			this._stack.push(name);
+		}
+
+		if(this._cbs.onopentagname) this._cbs.onopentagname(name);
+		if(this._cbs.onopentag) this._attribs = {};
 	};
 
-	module.exports = Timer;
+	Parser.prototype.onopentagend = function(){
+		this._updatePosition(1);
+
+		if(this._attribs){
+			if(this._cbs.onopentag) this._cbs.onopentag(this._tagname, this._attribs);
+			this._attribs = null;
+		}
+
+		if(!this._options.xmlMode && this._cbs.onclosetag && this._tagname in voidElements){
+			this._cbs.onclosetag(this._tagname);
+		}
+
+		this._tagname = "";
+	};
+
+	Parser.prototype.onclosetag = function(name){
+		this._updatePosition(1);
+
+		if(this._lowerCaseTagNames){
+			name = name.toLowerCase();
+		}
+
+		if(this._stack.length && (!(name in voidElements) || this._options.xmlMode)){
+			var pos = this._stack.lastIndexOf(name);
+			if(pos !== -1){
+				if(this._cbs.onclosetag){
+					pos = this._stack.length - pos;
+					while(pos--) this._cbs.onclosetag(this._stack.pop());
+				}
+				else this._stack.length = pos;
+			} else if(name === "p" && !this._options.xmlMode){
+				this.onopentagname(name);
+				this._closeCurrentTag();
+			}
+		} else if(!this._options.xmlMode && (name === "br" || name === "p")){
+			this.onopentagname(name);
+			this._closeCurrentTag();
+		}
+	};
+
+	Parser.prototype.onselfclosingtag = function(){
+		if(this._options.xmlMode || this._options.recognizeSelfClosing){
+			this._closeCurrentTag();
+		} else {
+			this.onopentagend();
+		}
+	};
+
+	Parser.prototype._closeCurrentTag = function(){
+		var name = this._tagname;
+
+		this.onopentagend();
+
+		//self-closing tags will be on the top of the stack
+		//(cheaper check than in onclosetag)
+		if(this._stack[this._stack.length - 1] === name){
+			if(this._cbs.onclosetag){
+				this._cbs.onclosetag(name);
+			}
+			this._stack.pop();
+		}
+	};
+
+	Parser.prototype.onattribname = function(name){
+		if(this._lowerCaseAttributeNames){
+			name = name.toLowerCase();
+		}
+		this._attribname = name;
+	};
+
+	Parser.prototype.onattribdata = function(value){
+		this._attribvalue += value;
+	};
+
+	Parser.prototype.onattribend = function(){
+		if(this._cbs.onattribute) this._cbs.onattribute(this._attribname, this._attribvalue);
+		if(
+			this._attribs &&
+			!Object.prototype.hasOwnProperty.call(this._attribs, this._attribname)
+		){
+			this._attribs[this._attribname] = this._attribvalue;
+		}
+		this._attribname = "";
+		this._attribvalue = "";
+	};
+
+	Parser.prototype._getInstructionName = function(value){
+		var idx = value.search(re_nameEnd),
+		    name = idx < 0 ? value : value.substr(0, idx);
+
+		if(this._lowerCaseTagNames){
+			name = name.toLowerCase();
+		}
+
+		return name;
+	};
+
+	Parser.prototype.ondeclaration = function(value){
+		if(this._cbs.onprocessinginstruction){
+			var name = this._getInstructionName(value);
+			this._cbs.onprocessinginstruction("!" + name, "!" + value);
+		}
+	};
+
+	Parser.prototype.onprocessinginstruction = function(value){
+		if(this._cbs.onprocessinginstruction){
+			var name = this._getInstructionName(value);
+			this._cbs.onprocessinginstruction("?" + name, "?" + value);
+		}
+	};
+
+	Parser.prototype.oncomment = function(value){
+		this._updatePosition(4);
+
+		if(this._cbs.oncomment) this._cbs.oncomment(value);
+		if(this._cbs.oncommentend) this._cbs.oncommentend();
+	};
+
+	Parser.prototype.oncdata = function(value){
+		this._updatePosition(1);
+
+		if(this._options.xmlMode || this._options.recognizeCDATA){
+			if(this._cbs.oncdatastart) this._cbs.oncdatastart();
+			if(this._cbs.ontext) this._cbs.ontext(value);
+			if(this._cbs.oncdataend) this._cbs.oncdataend();
+		} else {
+			this.oncomment("[CDATA[" + value + "]]");
+		}
+	};
+
+	Parser.prototype.onerror = function(err){
+		if(this._cbs.onerror) this._cbs.onerror(err);
+	};
+
+	Parser.prototype.onend = function(){
+		if(this._cbs.onclosetag){
+			for(
+				var i = this._stack.length;
+				i > 0;
+				this._cbs.onclosetag(this._stack[--i])
+			);
+		}
+		if(this._cbs.onend) this._cbs.onend();
+	};
+
+
+	//Resets the parser to a blank state, ready to parse a new HTML document
+	Parser.prototype.reset = function(){
+		if(this._cbs.onreset) this._cbs.onreset();
+		this._tokenizer.reset();
+
+		this._tagname = "";
+		this._attribname = "";
+		this._attribs = null;
+		this._stack = [];
+
+		if(this._cbs.onparserinit) this._cbs.onparserinit(this);
+	};
+
+	//Parses a complete HTML document and pushes it to the handler
+	Parser.prototype.parseComplete = function(data){
+		this.reset();
+		this.end(data);
+	};
+
+	Parser.prototype.write = function(chunk){
+		this._tokenizer.write(chunk);
+	};
+
+	Parser.prototype.end = function(chunk){
+		this._tokenizer.end(chunk);
+	};
+
+	Parser.prototype.pause = function(){
+		this._tokenizer.pause();
+	};
+
+	Parser.prototype.resume = function(){
+		this._tokenizer.resume();
+	};
+
+	//alias for backwards compat
+	Parser.prototype.parseChunk = Parser.prototype.write;
+	Parser.prototype.done = Parser.prototype.end;
+
+	module.exports = Parser;
 
 
 /***/ },
 /* 10 */
-/***/ function(module, exports) {
+/***/ function(module, exports, __webpack_require__) {
 
-	/**
-	 * Thread is an internal data structure used by the interpreter. It holds the
-	 * state of a thread so it can continue from where it left off, and it has
-	 * a stack to support nested control structures and procedure calls.
-	 *
-	 * @param {String} Unique block identifier
-	 */
-	function Thread (id) {
-	    this.topBlockId = id;
-	    this.blockPointer = id;
-	    this.blockFirstTime = -1;
-	    this.nextBlock = null;
-	    this.waiting = null;
-	    this.runningDeviceBlock = false;
-	    this.stack = [];
-	    this.repeatCounter = -1;
+	module.exports = Tokenizer;
+
+	var decodeCodePoint = __webpack_require__(11),
+	    entityMap = __webpack_require__(13),
+	    legacyMap = __webpack_require__(14),
+	    xmlMap    = __webpack_require__(15),
+
+	    i = 0,
+
+	    TEXT                      = i++,
+	    BEFORE_TAG_NAME           = i++, //after <
+	    IN_TAG_NAME               = i++,
+	    IN_SELF_CLOSING_TAG       = i++,
+	    BEFORE_CLOSING_TAG_NAME   = i++,
+	    IN_CLOSING_TAG_NAME       = i++,
+	    AFTER_CLOSING_TAG_NAME    = i++,
+
+	    //attributes
+	    BEFORE_ATTRIBUTE_NAME     = i++,
+	    IN_ATTRIBUTE_NAME         = i++,
+	    AFTER_ATTRIBUTE_NAME      = i++,
+	    BEFORE_ATTRIBUTE_VALUE    = i++,
+	    IN_ATTRIBUTE_VALUE_DQ     = i++, // "
+	    IN_ATTRIBUTE_VALUE_SQ     = i++, // '
+	    IN_ATTRIBUTE_VALUE_NQ     = i++,
+
+	    //declarations
+	    BEFORE_DECLARATION        = i++, // !
+	    IN_DECLARATION            = i++,
+
+	    //processing instructions
+	    IN_PROCESSING_INSTRUCTION = i++, // ?
+
+	    //comments
+	    BEFORE_COMMENT            = i++,
+	    IN_COMMENT                = i++,
+	    AFTER_COMMENT_1           = i++,
+	    AFTER_COMMENT_2           = i++,
+
+	    //cdata
+	    BEFORE_CDATA_1            = i++, // [
+	    BEFORE_CDATA_2            = i++, // C
+	    BEFORE_CDATA_3            = i++, // D
+	    BEFORE_CDATA_4            = i++, // A
+	    BEFORE_CDATA_5            = i++, // T
+	    BEFORE_CDATA_6            = i++, // A
+	    IN_CDATA                  = i++, // [
+	    AFTER_CDATA_1             = i++, // ]
+	    AFTER_CDATA_2             = i++, // ]
+
+	    //special tags
+	    BEFORE_SPECIAL            = i++, //S
+	    BEFORE_SPECIAL_END        = i++,   //S
+
+	    BEFORE_SCRIPT_1           = i++, //C
+	    BEFORE_SCRIPT_2           = i++, //R
+	    BEFORE_SCRIPT_3           = i++, //I
+	    BEFORE_SCRIPT_4           = i++, //P
+	    BEFORE_SCRIPT_5           = i++, //T
+	    AFTER_SCRIPT_1            = i++, //C
+	    AFTER_SCRIPT_2            = i++, //R
+	    AFTER_SCRIPT_3            = i++, //I
+	    AFTER_SCRIPT_4            = i++, //P
+	    AFTER_SCRIPT_5            = i++, //T
+
+	    BEFORE_STYLE_1            = i++, //T
+	    BEFORE_STYLE_2            = i++, //Y
+	    BEFORE_STYLE_3            = i++, //L
+	    BEFORE_STYLE_4            = i++, //E
+	    AFTER_STYLE_1             = i++, //T
+	    AFTER_STYLE_2             = i++, //Y
+	    AFTER_STYLE_3             = i++, //L
+	    AFTER_STYLE_4             = i++, //E
+
+	    BEFORE_ENTITY             = i++, //&
+	    BEFORE_NUMERIC_ENTITY     = i++, //#
+	    IN_NAMED_ENTITY           = i++,
+	    IN_NUMERIC_ENTITY         = i++,
+	    IN_HEX_ENTITY             = i++, //X
+
+	    j = 0,
+
+	    SPECIAL_NONE              = j++,
+	    SPECIAL_SCRIPT            = j++,
+	    SPECIAL_STYLE             = j++;
+
+	function whitespace(c){
+		return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
 	}
 
-	module.exports = Thread;
+	function characterState(char, SUCCESS){
+		return function(c){
+			if(c === char) this._state = SUCCESS;
+		};
+	}
+
+	function ifElseState(upper, SUCCESS, FAILURE){
+		var lower = upper.toLowerCase();
+
+		if(upper === lower){
+			return function(c){
+				if(c === lower){
+					this._state = SUCCESS;
+				} else {
+					this._state = FAILURE;
+					this._index--;
+				}
+			};
+		} else {
+			return function(c){
+				if(c === lower || c === upper){
+					this._state = SUCCESS;
+				} else {
+					this._state = FAILURE;
+					this._index--;
+				}
+			};
+		}
+	}
+
+	function consumeSpecialNameChar(upper, NEXT_STATE){
+		var lower = upper.toLowerCase();
+
+		return function(c){
+			if(c === lower || c === upper){
+				this._state = NEXT_STATE;
+			} else {
+				this._state = IN_TAG_NAME;
+				this._index--; //consume the token again
+			}
+		};
+	}
+
+	function Tokenizer(options, cbs){
+		this._state = TEXT;
+		this._buffer = "";
+		this._sectionStart = 0;
+		this._index = 0;
+		this._bufferOffset = 0; //chars removed from _buffer
+		this._baseState = TEXT;
+		this._special = SPECIAL_NONE;
+		this._cbs = cbs;
+		this._running = true;
+		this._ended = false;
+		this._xmlMode = !!(options && options.xmlMode);
+		this._decodeEntities = !!(options && options.decodeEntities);
+	}
+
+	Tokenizer.prototype._stateText = function(c){
+		if(c === "<"){
+			if(this._index > this._sectionStart){
+				this._cbs.ontext(this._getSection());
+			}
+			this._state = BEFORE_TAG_NAME;
+			this._sectionStart = this._index;
+		} else if(this._decodeEntities && this._special === SPECIAL_NONE && c === "&"){
+			if(this._index > this._sectionStart){
+				this._cbs.ontext(this._getSection());
+			}
+			this._baseState = TEXT;
+			this._state = BEFORE_ENTITY;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeTagName = function(c){
+		if(c === "/"){
+			this._state = BEFORE_CLOSING_TAG_NAME;
+		} else if(c === ">" || this._special !== SPECIAL_NONE || whitespace(c)) {
+			this._state = TEXT;
+		} else if(c === "!"){
+			this._state = BEFORE_DECLARATION;
+			this._sectionStart = this._index + 1;
+		} else if(c === "?"){
+			this._state = IN_PROCESSING_INSTRUCTION;
+			this._sectionStart = this._index + 1;
+		} else if(c === "<"){
+			this._cbs.ontext(this._getSection());
+			this._sectionStart = this._index;
+		} else {
+			this._state = (!this._xmlMode && (c === "s" || c === "S")) ?
+							BEFORE_SPECIAL : IN_TAG_NAME;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateInTagName = function(c){
+		if(c === "/" || c === ">" || whitespace(c)){
+			this._emitToken("onopentagname");
+			this._state = BEFORE_ATTRIBUTE_NAME;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeCloseingTagName = function(c){
+		if(whitespace(c));
+		else if(c === ">"){
+			this._state = TEXT;
+		} else if(this._special !== SPECIAL_NONE){
+			if(c === "s" || c === "S"){
+				this._state = BEFORE_SPECIAL_END;
+			} else {
+				this._state = TEXT;
+				this._index--;
+			}
+		} else {
+			this._state = IN_CLOSING_TAG_NAME;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateInCloseingTagName = function(c){
+		if(c === ">" || whitespace(c)){
+			this._emitToken("onclosetag");
+			this._state = AFTER_CLOSING_TAG_NAME;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateAfterCloseingTagName = function(c){
+		//skip everything until ">"
+		if(c === ">"){
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeAttributeName = function(c){
+		if(c === ">"){
+			this._cbs.onopentagend();
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		} else if(c === "/"){
+			this._state = IN_SELF_CLOSING_TAG;
+		} else if(!whitespace(c)){
+			this._state = IN_ATTRIBUTE_NAME;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateInSelfClosingTag = function(c){
+		if(c === ">"){
+			this._cbs.onselfclosingtag();
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		} else if(!whitespace(c)){
+			this._state = BEFORE_ATTRIBUTE_NAME;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateInAttributeName = function(c){
+		if(c === "=" || c === "/" || c === ">" || whitespace(c)){
+			this._cbs.onattribname(this._getSection());
+			this._sectionStart = -1;
+			this._state = AFTER_ATTRIBUTE_NAME;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateAfterAttributeName = function(c){
+		if(c === "="){
+			this._state = BEFORE_ATTRIBUTE_VALUE;
+		} else if(c === "/" || c === ">"){
+			this._cbs.onattribend();
+			this._state = BEFORE_ATTRIBUTE_NAME;
+			this._index--;
+		} else if(!whitespace(c)){
+			this._cbs.onattribend();
+			this._state = IN_ATTRIBUTE_NAME;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeAttributeValue = function(c){
+		if(c === "\""){
+			this._state = IN_ATTRIBUTE_VALUE_DQ;
+			this._sectionStart = this._index + 1;
+		} else if(c === "'"){
+			this._state = IN_ATTRIBUTE_VALUE_SQ;
+			this._sectionStart = this._index + 1;
+		} else if(!whitespace(c)){
+			this._state = IN_ATTRIBUTE_VALUE_NQ;
+			this._sectionStart = this._index;
+			this._index--; //reconsume token
+		}
+	};
+
+	Tokenizer.prototype._stateInAttributeValueDoubleQuotes = function(c){
+		if(c === "\""){
+			this._emitToken("onattribdata");
+			this._cbs.onattribend();
+			this._state = BEFORE_ATTRIBUTE_NAME;
+		} else if(this._decodeEntities && c === "&"){
+			this._emitToken("onattribdata");
+			this._baseState = this._state;
+			this._state = BEFORE_ENTITY;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateInAttributeValueSingleQuotes = function(c){
+		if(c === "'"){
+			this._emitToken("onattribdata");
+			this._cbs.onattribend();
+			this._state = BEFORE_ATTRIBUTE_NAME;
+		} else if(this._decodeEntities && c === "&"){
+			this._emitToken("onattribdata");
+			this._baseState = this._state;
+			this._state = BEFORE_ENTITY;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateInAttributeValueNoQuotes = function(c){
+		if(whitespace(c) || c === ">"){
+			this._emitToken("onattribdata");
+			this._cbs.onattribend();
+			this._state = BEFORE_ATTRIBUTE_NAME;
+			this._index--;
+		} else if(this._decodeEntities && c === "&"){
+			this._emitToken("onattribdata");
+			this._baseState = this._state;
+			this._state = BEFORE_ENTITY;
+			this._sectionStart = this._index;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeDeclaration = function(c){
+		this._state = c === "[" ? BEFORE_CDATA_1 :
+						c === "-" ? BEFORE_COMMENT :
+							IN_DECLARATION;
+	};
+
+	Tokenizer.prototype._stateInDeclaration = function(c){
+		if(c === ">"){
+			this._cbs.ondeclaration(this._getSection());
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		}
+	};
+
+	Tokenizer.prototype._stateInProcessingInstruction = function(c){
+		if(c === ">"){
+			this._cbs.onprocessinginstruction(this._getSection());
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeComment = function(c){
+		if(c === "-"){
+			this._state = IN_COMMENT;
+			this._sectionStart = this._index + 1;
+		} else {
+			this._state = IN_DECLARATION;
+		}
+	};
+
+	Tokenizer.prototype._stateInComment = function(c){
+		if(c === "-") this._state = AFTER_COMMENT_1;
+	};
+
+	Tokenizer.prototype._stateAfterComment1 = function(c){
+		if(c === "-"){
+			this._state = AFTER_COMMENT_2;
+		} else {
+			this._state = IN_COMMENT;
+		}
+	};
+
+	Tokenizer.prototype._stateAfterComment2 = function(c){
+		if(c === ">"){
+			//remove 2 trailing chars
+			this._cbs.oncomment(this._buffer.substring(this._sectionStart, this._index - 2));
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		} else if(c !== "-"){
+			this._state = IN_COMMENT;
+		}
+		// else: stay in AFTER_COMMENT_2 (`--->`)
+	};
+
+	Tokenizer.prototype._stateBeforeCdata1 = ifElseState("C", BEFORE_CDATA_2, IN_DECLARATION);
+	Tokenizer.prototype._stateBeforeCdata2 = ifElseState("D", BEFORE_CDATA_3, IN_DECLARATION);
+	Tokenizer.prototype._stateBeforeCdata3 = ifElseState("A", BEFORE_CDATA_4, IN_DECLARATION);
+	Tokenizer.prototype._stateBeforeCdata4 = ifElseState("T", BEFORE_CDATA_5, IN_DECLARATION);
+	Tokenizer.prototype._stateBeforeCdata5 = ifElseState("A", BEFORE_CDATA_6, IN_DECLARATION);
+
+	Tokenizer.prototype._stateBeforeCdata6 = function(c){
+		if(c === "["){
+			this._state = IN_CDATA;
+			this._sectionStart = this._index + 1;
+		} else {
+			this._state = IN_DECLARATION;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateInCdata = function(c){
+		if(c === "]") this._state = AFTER_CDATA_1;
+	};
+
+	Tokenizer.prototype._stateAfterCdata1 = characterState("]", AFTER_CDATA_2);
+
+	Tokenizer.prototype._stateAfterCdata2 = function(c){
+		if(c === ">"){
+			//remove 2 trailing chars
+			this._cbs.oncdata(this._buffer.substring(this._sectionStart, this._index - 2));
+			this._state = TEXT;
+			this._sectionStart = this._index + 1;
+		} else if(c !== "]") {
+			this._state = IN_CDATA;
+		}
+		//else: stay in AFTER_CDATA_2 (`]]]>`)
+	};
+
+	Tokenizer.prototype._stateBeforeSpecial = function(c){
+		if(c === "c" || c === "C"){
+			this._state = BEFORE_SCRIPT_1;
+		} else if(c === "t" || c === "T"){
+			this._state = BEFORE_STYLE_1;
+		} else {
+			this._state = IN_TAG_NAME;
+			this._index--; //consume the token again
+		}
+	};
+
+	Tokenizer.prototype._stateBeforeSpecialEnd = function(c){
+		if(this._special === SPECIAL_SCRIPT && (c === "c" || c === "C")){
+			this._state = AFTER_SCRIPT_1;
+		} else if(this._special === SPECIAL_STYLE && (c === "t" || c === "T")){
+			this._state = AFTER_STYLE_1;
+		}
+		else this._state = TEXT;
+	};
+
+	Tokenizer.prototype._stateBeforeScript1 = consumeSpecialNameChar("R", BEFORE_SCRIPT_2);
+	Tokenizer.prototype._stateBeforeScript2 = consumeSpecialNameChar("I", BEFORE_SCRIPT_3);
+	Tokenizer.prototype._stateBeforeScript3 = consumeSpecialNameChar("P", BEFORE_SCRIPT_4);
+	Tokenizer.prototype._stateBeforeScript4 = consumeSpecialNameChar("T", BEFORE_SCRIPT_5);
+
+	Tokenizer.prototype._stateBeforeScript5 = function(c){
+		if(c === "/" || c === ">" || whitespace(c)){
+			this._special = SPECIAL_SCRIPT;
+		}
+		this._state = IN_TAG_NAME;
+		this._index--; //consume the token again
+	};
+
+	Tokenizer.prototype._stateAfterScript1 = ifElseState("R", AFTER_SCRIPT_2, TEXT);
+	Tokenizer.prototype._stateAfterScript2 = ifElseState("I", AFTER_SCRIPT_3, TEXT);
+	Tokenizer.prototype._stateAfterScript3 = ifElseState("P", AFTER_SCRIPT_4, TEXT);
+	Tokenizer.prototype._stateAfterScript4 = ifElseState("T", AFTER_SCRIPT_5, TEXT);
+
+	Tokenizer.prototype._stateAfterScript5 = function(c){
+		if(c === ">" || whitespace(c)){
+			this._special = SPECIAL_NONE;
+			this._state = IN_CLOSING_TAG_NAME;
+			this._sectionStart = this._index - 6;
+			this._index--; //reconsume the token
+		}
+		else this._state = TEXT;
+	};
+
+	Tokenizer.prototype._stateBeforeStyle1 = consumeSpecialNameChar("Y", BEFORE_STYLE_2);
+	Tokenizer.prototype._stateBeforeStyle2 = consumeSpecialNameChar("L", BEFORE_STYLE_3);
+	Tokenizer.prototype._stateBeforeStyle3 = consumeSpecialNameChar("E", BEFORE_STYLE_4);
+
+	Tokenizer.prototype._stateBeforeStyle4 = function(c){
+		if(c === "/" || c === ">" || whitespace(c)){
+			this._special = SPECIAL_STYLE;
+		}
+		this._state = IN_TAG_NAME;
+		this._index--; //consume the token again
+	};
+
+	Tokenizer.prototype._stateAfterStyle1 = ifElseState("Y", AFTER_STYLE_2, TEXT);
+	Tokenizer.prototype._stateAfterStyle2 = ifElseState("L", AFTER_STYLE_3, TEXT);
+	Tokenizer.prototype._stateAfterStyle3 = ifElseState("E", AFTER_STYLE_4, TEXT);
+
+	Tokenizer.prototype._stateAfterStyle4 = function(c){
+		if(c === ">" || whitespace(c)){
+			this._special = SPECIAL_NONE;
+			this._state = IN_CLOSING_TAG_NAME;
+			this._sectionStart = this._index - 5;
+			this._index--; //reconsume the token
+		}
+		else this._state = TEXT;
+	};
+
+	Tokenizer.prototype._stateBeforeEntity = ifElseState("#", BEFORE_NUMERIC_ENTITY, IN_NAMED_ENTITY);
+	Tokenizer.prototype._stateBeforeNumericEntity = ifElseState("X", IN_HEX_ENTITY, IN_NUMERIC_ENTITY);
+
+	//for entities terminated with a semicolon
+	Tokenizer.prototype._parseNamedEntityStrict = function(){
+		//offset = 1
+		if(this._sectionStart + 1 < this._index){
+			var entity = this._buffer.substring(this._sectionStart + 1, this._index),
+			    map = this._xmlMode ? xmlMap : entityMap;
+
+			if(map.hasOwnProperty(entity)){
+				this._emitPartial(map[entity]);
+				this._sectionStart = this._index + 1;
+			}
+		}
+	};
+
+
+	//parses legacy entities (without trailing semicolon)
+	Tokenizer.prototype._parseLegacyEntity = function(){
+		var start = this._sectionStart + 1,
+		    limit = this._index - start;
+
+		if(limit > 6) limit = 6; //the max length of legacy entities is 6
+
+		while(limit >= 2){ //the min length of legacy entities is 2
+			var entity = this._buffer.substr(start, limit);
+
+			if(legacyMap.hasOwnProperty(entity)){
+				this._emitPartial(legacyMap[entity]);
+				this._sectionStart += limit + 1;
+				return;
+			} else {
+				limit--;
+			}
+		}
+	};
+
+	Tokenizer.prototype._stateInNamedEntity = function(c){
+		if(c === ";"){
+			this._parseNamedEntityStrict();
+			if(this._sectionStart + 1 < this._index && !this._xmlMode){
+				this._parseLegacyEntity();
+			}
+			this._state = this._baseState;
+		} else if((c < "a" || c > "z") && (c < "A" || c > "Z") && (c < "0" || c > "9")){
+			if(this._xmlMode);
+			else if(this._sectionStart + 1 === this._index);
+			else if(this._baseState !== TEXT){
+				if(c !== "="){
+					this._parseNamedEntityStrict();
+				}
+			} else {
+				this._parseLegacyEntity();
+			}
+
+			this._state = this._baseState;
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._decodeNumericEntity = function(offset, base){
+		var sectionStart = this._sectionStart + offset;
+
+		if(sectionStart !== this._index){
+			//parse entity
+			var entity = this._buffer.substring(sectionStart, this._index);
+			var parsed = parseInt(entity, base);
+
+			this._emitPartial(decodeCodePoint(parsed));
+			this._sectionStart = this._index;
+		} else {
+			this._sectionStart--;
+		}
+
+		this._state = this._baseState;
+	};
+
+	Tokenizer.prototype._stateInNumericEntity = function(c){
+		if(c === ";"){
+			this._decodeNumericEntity(2, 10);
+			this._sectionStart++;
+		} else if(c < "0" || c > "9"){
+			if(!this._xmlMode){
+				this._decodeNumericEntity(2, 10);
+			} else {
+				this._state = this._baseState;
+			}
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._stateInHexEntity = function(c){
+		if(c === ";"){
+			this._decodeNumericEntity(3, 16);
+			this._sectionStart++;
+		} else if((c < "a" || c > "f") && (c < "A" || c > "F") && (c < "0" || c > "9")){
+			if(!this._xmlMode){
+				this._decodeNumericEntity(3, 16);
+			} else {
+				this._state = this._baseState;
+			}
+			this._index--;
+		}
+	};
+
+	Tokenizer.prototype._cleanup = function (){
+		if(this._sectionStart < 0){
+			this._buffer = "";
+			this._index = 0;
+			this._bufferOffset += this._index;
+		} else if(this._running){
+			if(this._state === TEXT){
+				if(this._sectionStart !== this._index){
+					this._cbs.ontext(this._buffer.substr(this._sectionStart));
+				}
+				this._buffer = "";
+				this._index = 0;
+				this._bufferOffset += this._index;
+			} else if(this._sectionStart === this._index){
+				//the section just started
+				this._buffer = "";
+				this._index = 0;
+				this._bufferOffset += this._index;
+			} else {
+				//remove everything unnecessary
+				this._buffer = this._buffer.substr(this._sectionStart);
+				this._index -= this._sectionStart;
+				this._bufferOffset += this._sectionStart;
+			}
+
+			this._sectionStart = 0;
+		}
+	};
+
+	//TODO make events conditional
+	Tokenizer.prototype.write = function(chunk){
+		if(this._ended) this._cbs.onerror(Error(".write() after done!"));
+
+		this._buffer += chunk;
+		this._parse();
+	};
+
+	Tokenizer.prototype._parse = function(){
+		while(this._index < this._buffer.length && this._running){
+			var c = this._buffer.charAt(this._index);
+			if(this._state === TEXT) {
+				this._stateText(c);
+			} else if(this._state === BEFORE_TAG_NAME){
+				this._stateBeforeTagName(c);
+			} else if(this._state === IN_TAG_NAME) {
+				this._stateInTagName(c);
+			} else if(this._state === BEFORE_CLOSING_TAG_NAME){
+				this._stateBeforeCloseingTagName(c);
+			} else if(this._state === IN_CLOSING_TAG_NAME){
+				this._stateInCloseingTagName(c);
+			} else if(this._state === AFTER_CLOSING_TAG_NAME){
+				this._stateAfterCloseingTagName(c);
+			} else if(this._state === IN_SELF_CLOSING_TAG){
+				this._stateInSelfClosingTag(c);
+			}
+
+			/*
+			*	attributes
+			*/
+			else if(this._state === BEFORE_ATTRIBUTE_NAME){
+				this._stateBeforeAttributeName(c);
+			} else if(this._state === IN_ATTRIBUTE_NAME){
+				this._stateInAttributeName(c);
+			} else if(this._state === AFTER_ATTRIBUTE_NAME){
+				this._stateAfterAttributeName(c);
+			} else if(this._state === BEFORE_ATTRIBUTE_VALUE){
+				this._stateBeforeAttributeValue(c);
+			} else if(this._state === IN_ATTRIBUTE_VALUE_DQ){
+				this._stateInAttributeValueDoubleQuotes(c);
+			} else if(this._state === IN_ATTRIBUTE_VALUE_SQ){
+				this._stateInAttributeValueSingleQuotes(c);
+			} else if(this._state === IN_ATTRIBUTE_VALUE_NQ){
+				this._stateInAttributeValueNoQuotes(c);
+			}
+
+			/*
+			*	declarations
+			*/
+			else if(this._state === BEFORE_DECLARATION){
+				this._stateBeforeDeclaration(c);
+			} else if(this._state === IN_DECLARATION){
+				this._stateInDeclaration(c);
+			}
+
+			/*
+			*	processing instructions
+			*/
+			else if(this._state === IN_PROCESSING_INSTRUCTION){
+				this._stateInProcessingInstruction(c);
+			}
+
+			/*
+			*	comments
+			*/
+			else if(this._state === BEFORE_COMMENT){
+				this._stateBeforeComment(c);
+			} else if(this._state === IN_COMMENT){
+				this._stateInComment(c);
+			} else if(this._state === AFTER_COMMENT_1){
+				this._stateAfterComment1(c);
+			} else if(this._state === AFTER_COMMENT_2){
+				this._stateAfterComment2(c);
+			}
+
+			/*
+			*	cdata
+			*/
+			else if(this._state === BEFORE_CDATA_1){
+				this._stateBeforeCdata1(c);
+			} else if(this._state === BEFORE_CDATA_2){
+				this._stateBeforeCdata2(c);
+			} else if(this._state === BEFORE_CDATA_3){
+				this._stateBeforeCdata3(c);
+			} else if(this._state === BEFORE_CDATA_4){
+				this._stateBeforeCdata4(c);
+			} else if(this._state === BEFORE_CDATA_5){
+				this._stateBeforeCdata5(c);
+			} else if(this._state === BEFORE_CDATA_6){
+				this._stateBeforeCdata6(c);
+			} else if(this._state === IN_CDATA){
+				this._stateInCdata(c);
+			} else if(this._state === AFTER_CDATA_1){
+				this._stateAfterCdata1(c);
+			} else if(this._state === AFTER_CDATA_2){
+				this._stateAfterCdata2(c);
+			}
+
+			/*
+			* special tags
+			*/
+			else if(this._state === BEFORE_SPECIAL){
+				this._stateBeforeSpecial(c);
+			} else if(this._state === BEFORE_SPECIAL_END){
+				this._stateBeforeSpecialEnd(c);
+			}
+
+			/*
+			* script
+			*/
+			else if(this._state === BEFORE_SCRIPT_1){
+				this._stateBeforeScript1(c);
+			} else if(this._state === BEFORE_SCRIPT_2){
+				this._stateBeforeScript2(c);
+			} else if(this._state === BEFORE_SCRIPT_3){
+				this._stateBeforeScript3(c);
+			} else if(this._state === BEFORE_SCRIPT_4){
+				this._stateBeforeScript4(c);
+			} else if(this._state === BEFORE_SCRIPT_5){
+				this._stateBeforeScript5(c);
+			}
+
+			else if(this._state === AFTER_SCRIPT_1){
+				this._stateAfterScript1(c);
+			} else if(this._state === AFTER_SCRIPT_2){
+				this._stateAfterScript2(c);
+			} else if(this._state === AFTER_SCRIPT_3){
+				this._stateAfterScript3(c);
+			} else if(this._state === AFTER_SCRIPT_4){
+				this._stateAfterScript4(c);
+			} else if(this._state === AFTER_SCRIPT_5){
+				this._stateAfterScript5(c);
+			}
+
+			/*
+			* style
+			*/
+			else if(this._state === BEFORE_STYLE_1){
+				this._stateBeforeStyle1(c);
+			} else if(this._state === BEFORE_STYLE_2){
+				this._stateBeforeStyle2(c);
+			} else if(this._state === BEFORE_STYLE_3){
+				this._stateBeforeStyle3(c);
+			} else if(this._state === BEFORE_STYLE_4){
+				this._stateBeforeStyle4(c);
+			}
+
+			else if(this._state === AFTER_STYLE_1){
+				this._stateAfterStyle1(c);
+			} else if(this._state === AFTER_STYLE_2){
+				this._stateAfterStyle2(c);
+			} else if(this._state === AFTER_STYLE_3){
+				this._stateAfterStyle3(c);
+			} else if(this._state === AFTER_STYLE_4){
+				this._stateAfterStyle4(c);
+			}
+
+			/*
+			* entities
+			*/
+			else if(this._state === BEFORE_ENTITY){
+				this._stateBeforeEntity(c);
+			} else if(this._state === BEFORE_NUMERIC_ENTITY){
+				this._stateBeforeNumericEntity(c);
+			} else if(this._state === IN_NAMED_ENTITY){
+				this._stateInNamedEntity(c);
+			} else if(this._state === IN_NUMERIC_ENTITY){
+				this._stateInNumericEntity(c);
+			} else if(this._state === IN_HEX_ENTITY){
+				this._stateInHexEntity(c);
+			}
+
+			else {
+				this._cbs.onerror(Error("unknown _state"), this._state);
+			}
+
+			this._index++;
+		}
+
+		this._cleanup();
+	};
+
+	Tokenizer.prototype.pause = function(){
+		this._running = false;
+	};
+	Tokenizer.prototype.resume = function(){
+		this._running = true;
+
+		if(this._index < this._buffer.length){
+			this._parse();
+		}
+		if(this._ended){
+			this._finish();
+		}
+	};
+
+	Tokenizer.prototype.end = function(chunk){
+		if(this._ended) this._cbs.onerror(Error(".end() after done!"));
+		if(chunk) this.write(chunk);
+
+		this._ended = true;
+
+		if(this._running) this._finish();
+	};
+
+	Tokenizer.prototype._finish = function(){
+		//if there is remaining data, emit it in a reasonable way
+		if(this._sectionStart < this._index){
+			this._handleTrailingData();
+		}
+
+		this._cbs.onend();
+	};
+
+	Tokenizer.prototype._handleTrailingData = function(){
+		var data = this._buffer.substr(this._sectionStart);
+
+		if(this._state === IN_CDATA || this._state === AFTER_CDATA_1 || this._state === AFTER_CDATA_2){
+			this._cbs.oncdata(data);
+		} else if(this._state === IN_COMMENT || this._state === AFTER_COMMENT_1 || this._state === AFTER_COMMENT_2){
+			this._cbs.oncomment(data);
+		} else if(this._state === IN_NAMED_ENTITY && !this._xmlMode){
+			this._parseLegacyEntity();
+			if(this._sectionStart < this._index){
+				this._state = this._baseState;
+				this._handleTrailingData();
+			}
+		} else if(this._state === IN_NUMERIC_ENTITY && !this._xmlMode){
+			this._decodeNumericEntity(2, 10);
+			if(this._sectionStart < this._index){
+				this._state = this._baseState;
+				this._handleTrailingData();
+			}
+		} else if(this._state === IN_HEX_ENTITY && !this._xmlMode){
+			this._decodeNumericEntity(3, 16);
+			if(this._sectionStart < this._index){
+				this._state = this._baseState;
+				this._handleTrailingData();
+			}
+		} else if(
+			this._state !== IN_TAG_NAME &&
+			this._state !== BEFORE_ATTRIBUTE_NAME &&
+			this._state !== BEFORE_ATTRIBUTE_VALUE &&
+			this._state !== AFTER_ATTRIBUTE_NAME &&
+			this._state !== IN_ATTRIBUTE_NAME &&
+			this._state !== IN_ATTRIBUTE_VALUE_SQ &&
+			this._state !== IN_ATTRIBUTE_VALUE_DQ &&
+			this._state !== IN_ATTRIBUTE_VALUE_NQ &&
+			this._state !== IN_CLOSING_TAG_NAME
+		){
+			this._cbs.ontext(data);
+		}
+		//else, ignore remaining data
+		//TODO add a way to remove current tag
+	};
+
+	Tokenizer.prototype.reset = function(){
+		Tokenizer.call(this, {xmlMode: this._xmlMode, decodeEntities: this._decodeEntities}, this._cbs);
+	};
+
+	Tokenizer.prototype.getAbsoluteIndex = function(){
+		return this._bufferOffset + this._index;
+	};
+
+	Tokenizer.prototype._getSection = function(){
+		return this._buffer.substring(this._sectionStart, this._index);
+	};
+
+	Tokenizer.prototype._emitToken = function(name){
+		this._cbs[name](this._getSection());
+		this._sectionStart = -1;
+	};
+
+	Tokenizer.prototype._emitPartial = function(value){
+		if(this._baseState !== TEXT){
+			this._cbs.onattribdata(value); //TODO implement the new event
+		} else {
+			this._cbs.ontext(value);
+		}
+	};
+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var decodeMap = __webpack_require__(12);
+
+	module.exports = decodeCodePoint;
+
+	// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
+	function decodeCodePoint(codePoint){
+
+		if((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF){
+			return "\uFFFD";
+		}
+
+		if(codePoint in decodeMap){
+			codePoint = decodeMap[codePoint];
+		}
+
+		var output = "";
+
+		if(codePoint > 0xFFFF){
+			codePoint -= 0x10000;
+			output += String.fromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+			codePoint = 0xDC00 | codePoint & 0x3FF;
+		}
+
+		output += String.fromCharCode(codePoint);
+		return output;
+	}
+
+
+/***/ },
+/* 12 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"0": 65533,
+		"128": 8364,
+		"130": 8218,
+		"131": 402,
+		"132": 8222,
+		"133": 8230,
+		"134": 8224,
+		"135": 8225,
+		"136": 710,
+		"137": 8240,
+		"138": 352,
+		"139": 8249,
+		"140": 338,
+		"142": 381,
+		"145": 8216,
+		"146": 8217,
+		"147": 8220,
+		"148": 8221,
+		"149": 8226,
+		"150": 8211,
+		"151": 8212,
+		"152": 732,
+		"153": 8482,
+		"154": 353,
+		"155": 8250,
+		"156": 339,
+		"158": 382,
+		"159": 376
+	};
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"Aacute": "Á",
+		"aacute": "á",
+		"Abreve": "Ă",
+		"abreve": "ă",
+		"ac": "∾",
+		"acd": "∿",
+		"acE": "∾̳",
+		"Acirc": "Â",
+		"acirc": "â",
+		"acute": "´",
+		"Acy": "А",
+		"acy": "а",
+		"AElig": "Æ",
+		"aelig": "æ",
+		"af": "⁡",
+		"Afr": "𝔄",
+		"afr": "𝔞",
+		"Agrave": "À",
+		"agrave": "à",
+		"alefsym": "ℵ",
+		"aleph": "ℵ",
+		"Alpha": "Α",
+		"alpha": "α",
+		"Amacr": "Ā",
+		"amacr": "ā",
+		"amalg": "⨿",
+		"amp": "&",
+		"AMP": "&",
+		"andand": "⩕",
+		"And": "⩓",
+		"and": "∧",
+		"andd": "⩜",
+		"andslope": "⩘",
+		"andv": "⩚",
+		"ang": "∠",
+		"ange": "⦤",
+		"angle": "∠",
+		"angmsdaa": "⦨",
+		"angmsdab": "⦩",
+		"angmsdac": "⦪",
+		"angmsdad": "⦫",
+		"angmsdae": "⦬",
+		"angmsdaf": "⦭",
+		"angmsdag": "⦮",
+		"angmsdah": "⦯",
+		"angmsd": "∡",
+		"angrt": "∟",
+		"angrtvb": "⊾",
+		"angrtvbd": "⦝",
+		"angsph": "∢",
+		"angst": "Å",
+		"angzarr": "⍼",
+		"Aogon": "Ą",
+		"aogon": "ą",
+		"Aopf": "𝔸",
+		"aopf": "𝕒",
+		"apacir": "⩯",
+		"ap": "≈",
+		"apE": "⩰",
+		"ape": "≊",
+		"apid": "≋",
+		"apos": "'",
+		"ApplyFunction": "⁡",
+		"approx": "≈",
+		"approxeq": "≊",
+		"Aring": "Å",
+		"aring": "å",
+		"Ascr": "𝒜",
+		"ascr": "𝒶",
+		"Assign": "≔",
+		"ast": "*",
+		"asymp": "≈",
+		"asympeq": "≍",
+		"Atilde": "Ã",
+		"atilde": "ã",
+		"Auml": "Ä",
+		"auml": "ä",
+		"awconint": "∳",
+		"awint": "⨑",
+		"backcong": "≌",
+		"backepsilon": "϶",
+		"backprime": "‵",
+		"backsim": "∽",
+		"backsimeq": "⋍",
+		"Backslash": "∖",
+		"Barv": "⫧",
+		"barvee": "⊽",
+		"barwed": "⌅",
+		"Barwed": "⌆",
+		"barwedge": "⌅",
+		"bbrk": "⎵",
+		"bbrktbrk": "⎶",
+		"bcong": "≌",
+		"Bcy": "Б",
+		"bcy": "б",
+		"bdquo": "„",
+		"becaus": "∵",
+		"because": "∵",
+		"Because": "∵",
+		"bemptyv": "⦰",
+		"bepsi": "϶",
+		"bernou": "ℬ",
+		"Bernoullis": "ℬ",
+		"Beta": "Β",
+		"beta": "β",
+		"beth": "ℶ",
+		"between": "≬",
+		"Bfr": "𝔅",
+		"bfr": "𝔟",
+		"bigcap": "⋂",
+		"bigcirc": "◯",
+		"bigcup": "⋃",
+		"bigodot": "⨀",
+		"bigoplus": "⨁",
+		"bigotimes": "⨂",
+		"bigsqcup": "⨆",
+		"bigstar": "★",
+		"bigtriangledown": "▽",
+		"bigtriangleup": "△",
+		"biguplus": "⨄",
+		"bigvee": "⋁",
+		"bigwedge": "⋀",
+		"bkarow": "⤍",
+		"blacklozenge": "⧫",
+		"blacksquare": "▪",
+		"blacktriangle": "▴",
+		"blacktriangledown": "▾",
+		"blacktriangleleft": "◂",
+		"blacktriangleright": "▸",
+		"blank": "␣",
+		"blk12": "▒",
+		"blk14": "░",
+		"blk34": "▓",
+		"block": "█",
+		"bne": "=⃥",
+		"bnequiv": "≡⃥",
+		"bNot": "⫭",
+		"bnot": "⌐",
+		"Bopf": "𝔹",
+		"bopf": "𝕓",
+		"bot": "⊥",
+		"bottom": "⊥",
+		"bowtie": "⋈",
+		"boxbox": "⧉",
+		"boxdl": "┐",
+		"boxdL": "╕",
+		"boxDl": "╖",
+		"boxDL": "╗",
+		"boxdr": "┌",
+		"boxdR": "╒",
+		"boxDr": "╓",
+		"boxDR": "╔",
+		"boxh": "─",
+		"boxH": "═",
+		"boxhd": "┬",
+		"boxHd": "╤",
+		"boxhD": "╥",
+		"boxHD": "╦",
+		"boxhu": "┴",
+		"boxHu": "╧",
+		"boxhU": "╨",
+		"boxHU": "╩",
+		"boxminus": "⊟",
+		"boxplus": "⊞",
+		"boxtimes": "⊠",
+		"boxul": "┘",
+		"boxuL": "╛",
+		"boxUl": "╜",
+		"boxUL": "╝",
+		"boxur": "└",
+		"boxuR": "╘",
+		"boxUr": "╙",
+		"boxUR": "╚",
+		"boxv": "│",
+		"boxV": "║",
+		"boxvh": "┼",
+		"boxvH": "╪",
+		"boxVh": "╫",
+		"boxVH": "╬",
+		"boxvl": "┤",
+		"boxvL": "╡",
+		"boxVl": "╢",
+		"boxVL": "╣",
+		"boxvr": "├",
+		"boxvR": "╞",
+		"boxVr": "╟",
+		"boxVR": "╠",
+		"bprime": "‵",
+		"breve": "˘",
+		"Breve": "˘",
+		"brvbar": "¦",
+		"bscr": "𝒷",
+		"Bscr": "ℬ",
+		"bsemi": "⁏",
+		"bsim": "∽",
+		"bsime": "⋍",
+		"bsolb": "⧅",
+		"bsol": "\\",
+		"bsolhsub": "⟈",
+		"bull": "•",
+		"bullet": "•",
+		"bump": "≎",
+		"bumpE": "⪮",
+		"bumpe": "≏",
+		"Bumpeq": "≎",
+		"bumpeq": "≏",
+		"Cacute": "Ć",
+		"cacute": "ć",
+		"capand": "⩄",
+		"capbrcup": "⩉",
+		"capcap": "⩋",
+		"cap": "∩",
+		"Cap": "⋒",
+		"capcup": "⩇",
+		"capdot": "⩀",
+		"CapitalDifferentialD": "ⅅ",
+		"caps": "∩︀",
+		"caret": "⁁",
+		"caron": "ˇ",
+		"Cayleys": "ℭ",
+		"ccaps": "⩍",
+		"Ccaron": "Č",
+		"ccaron": "č",
+		"Ccedil": "Ç",
+		"ccedil": "ç",
+		"Ccirc": "Ĉ",
+		"ccirc": "ĉ",
+		"Cconint": "∰",
+		"ccups": "⩌",
+		"ccupssm": "⩐",
+		"Cdot": "Ċ",
+		"cdot": "ċ",
+		"cedil": "¸",
+		"Cedilla": "¸",
+		"cemptyv": "⦲",
+		"cent": "¢",
+		"centerdot": "·",
+		"CenterDot": "·",
+		"cfr": "𝔠",
+		"Cfr": "ℭ",
+		"CHcy": "Ч",
+		"chcy": "ч",
+		"check": "✓",
+		"checkmark": "✓",
+		"Chi": "Χ",
+		"chi": "χ",
+		"circ": "ˆ",
+		"circeq": "≗",
+		"circlearrowleft": "↺",
+		"circlearrowright": "↻",
+		"circledast": "⊛",
+		"circledcirc": "⊚",
+		"circleddash": "⊝",
+		"CircleDot": "⊙",
+		"circledR": "®",
+		"circledS": "Ⓢ",
+		"CircleMinus": "⊖",
+		"CirclePlus": "⊕",
+		"CircleTimes": "⊗",
+		"cir": "○",
+		"cirE": "⧃",
+		"cire": "≗",
+		"cirfnint": "⨐",
+		"cirmid": "⫯",
+		"cirscir": "⧂",
+		"ClockwiseContourIntegral": "∲",
+		"CloseCurlyDoubleQuote": "”",
+		"CloseCurlyQuote": "’",
+		"clubs": "♣",
+		"clubsuit": "♣",
+		"colon": ":",
+		"Colon": "∷",
+		"Colone": "⩴",
+		"colone": "≔",
+		"coloneq": "≔",
+		"comma": ",",
+		"commat": "@",
+		"comp": "∁",
+		"compfn": "∘",
+		"complement": "∁",
+		"complexes": "ℂ",
+		"cong": "≅",
+		"congdot": "⩭",
+		"Congruent": "≡",
+		"conint": "∮",
+		"Conint": "∯",
+		"ContourIntegral": "∮",
+		"copf": "𝕔",
+		"Copf": "ℂ",
+		"coprod": "∐",
+		"Coproduct": "∐",
+		"copy": "©",
+		"COPY": "©",
+		"copysr": "℗",
+		"CounterClockwiseContourIntegral": "∳",
+		"crarr": "↵",
+		"cross": "✗",
+		"Cross": "⨯",
+		"Cscr": "𝒞",
+		"cscr": "𝒸",
+		"csub": "⫏",
+		"csube": "⫑",
+		"csup": "⫐",
+		"csupe": "⫒",
+		"ctdot": "⋯",
+		"cudarrl": "⤸",
+		"cudarrr": "⤵",
+		"cuepr": "⋞",
+		"cuesc": "⋟",
+		"cularr": "↶",
+		"cularrp": "⤽",
+		"cupbrcap": "⩈",
+		"cupcap": "⩆",
+		"CupCap": "≍",
+		"cup": "∪",
+		"Cup": "⋓",
+		"cupcup": "⩊",
+		"cupdot": "⊍",
+		"cupor": "⩅",
+		"cups": "∪︀",
+		"curarr": "↷",
+		"curarrm": "⤼",
+		"curlyeqprec": "⋞",
+		"curlyeqsucc": "⋟",
+		"curlyvee": "⋎",
+		"curlywedge": "⋏",
+		"curren": "¤",
+		"curvearrowleft": "↶",
+		"curvearrowright": "↷",
+		"cuvee": "⋎",
+		"cuwed": "⋏",
+		"cwconint": "∲",
+		"cwint": "∱",
+		"cylcty": "⌭",
+		"dagger": "†",
+		"Dagger": "‡",
+		"daleth": "ℸ",
+		"darr": "↓",
+		"Darr": "↡",
+		"dArr": "⇓",
+		"dash": "‐",
+		"Dashv": "⫤",
+		"dashv": "⊣",
+		"dbkarow": "⤏",
+		"dblac": "˝",
+		"Dcaron": "Ď",
+		"dcaron": "ď",
+		"Dcy": "Д",
+		"dcy": "д",
+		"ddagger": "‡",
+		"ddarr": "⇊",
+		"DD": "ⅅ",
+		"dd": "ⅆ",
+		"DDotrahd": "⤑",
+		"ddotseq": "⩷",
+		"deg": "°",
+		"Del": "∇",
+		"Delta": "Δ",
+		"delta": "δ",
+		"demptyv": "⦱",
+		"dfisht": "⥿",
+		"Dfr": "𝔇",
+		"dfr": "𝔡",
+		"dHar": "⥥",
+		"dharl": "⇃",
+		"dharr": "⇂",
+		"DiacriticalAcute": "´",
+		"DiacriticalDot": "˙",
+		"DiacriticalDoubleAcute": "˝",
+		"DiacriticalGrave": "`",
+		"DiacriticalTilde": "˜",
+		"diam": "⋄",
+		"diamond": "⋄",
+		"Diamond": "⋄",
+		"diamondsuit": "♦",
+		"diams": "♦",
+		"die": "¨",
+		"DifferentialD": "ⅆ",
+		"digamma": "ϝ",
+		"disin": "⋲",
+		"div": "÷",
+		"divide": "÷",
+		"divideontimes": "⋇",
+		"divonx": "⋇",
+		"DJcy": "Ђ",
+		"djcy": "ђ",
+		"dlcorn": "⌞",
+		"dlcrop": "⌍",
+		"dollar": "$",
+		"Dopf": "𝔻",
+		"dopf": "𝕕",
+		"Dot": "¨",
+		"dot": "˙",
+		"DotDot": "⃜",
+		"doteq": "≐",
+		"doteqdot": "≑",
+		"DotEqual": "≐",
+		"dotminus": "∸",
+		"dotplus": "∔",
+		"dotsquare": "⊡",
+		"doublebarwedge": "⌆",
+		"DoubleContourIntegral": "∯",
+		"DoubleDot": "¨",
+		"DoubleDownArrow": "⇓",
+		"DoubleLeftArrow": "⇐",
+		"DoubleLeftRightArrow": "⇔",
+		"DoubleLeftTee": "⫤",
+		"DoubleLongLeftArrow": "⟸",
+		"DoubleLongLeftRightArrow": "⟺",
+		"DoubleLongRightArrow": "⟹",
+		"DoubleRightArrow": "⇒",
+		"DoubleRightTee": "⊨",
+		"DoubleUpArrow": "⇑",
+		"DoubleUpDownArrow": "⇕",
+		"DoubleVerticalBar": "∥",
+		"DownArrowBar": "⤓",
+		"downarrow": "↓",
+		"DownArrow": "↓",
+		"Downarrow": "⇓",
+		"DownArrowUpArrow": "⇵",
+		"DownBreve": "̑",
+		"downdownarrows": "⇊",
+		"downharpoonleft": "⇃",
+		"downharpoonright": "⇂",
+		"DownLeftRightVector": "⥐",
+		"DownLeftTeeVector": "⥞",
+		"DownLeftVectorBar": "⥖",
+		"DownLeftVector": "↽",
+		"DownRightTeeVector": "⥟",
+		"DownRightVectorBar": "⥗",
+		"DownRightVector": "⇁",
+		"DownTeeArrow": "↧",
+		"DownTee": "⊤",
+		"drbkarow": "⤐",
+		"drcorn": "⌟",
+		"drcrop": "⌌",
+		"Dscr": "𝒟",
+		"dscr": "𝒹",
+		"DScy": "Ѕ",
+		"dscy": "ѕ",
+		"dsol": "⧶",
+		"Dstrok": "Đ",
+		"dstrok": "đ",
+		"dtdot": "⋱",
+		"dtri": "▿",
+		"dtrif": "▾",
+		"duarr": "⇵",
+		"duhar": "⥯",
+		"dwangle": "⦦",
+		"DZcy": "Џ",
+		"dzcy": "џ",
+		"dzigrarr": "⟿",
+		"Eacute": "É",
+		"eacute": "é",
+		"easter": "⩮",
+		"Ecaron": "Ě",
+		"ecaron": "ě",
+		"Ecirc": "Ê",
+		"ecirc": "ê",
+		"ecir": "≖",
+		"ecolon": "≕",
+		"Ecy": "Э",
+		"ecy": "э",
+		"eDDot": "⩷",
+		"Edot": "Ė",
+		"edot": "ė",
+		"eDot": "≑",
+		"ee": "ⅇ",
+		"efDot": "≒",
+		"Efr": "𝔈",
+		"efr": "𝔢",
+		"eg": "⪚",
+		"Egrave": "È",
+		"egrave": "è",
+		"egs": "⪖",
+		"egsdot": "⪘",
+		"el": "⪙",
+		"Element": "∈",
+		"elinters": "⏧",
+		"ell": "ℓ",
+		"els": "⪕",
+		"elsdot": "⪗",
+		"Emacr": "Ē",
+		"emacr": "ē",
+		"empty": "∅",
+		"emptyset": "∅",
+		"EmptySmallSquare": "◻",
+		"emptyv": "∅",
+		"EmptyVerySmallSquare": "▫",
+		"emsp13": " ",
+		"emsp14": " ",
+		"emsp": " ",
+		"ENG": "Ŋ",
+		"eng": "ŋ",
+		"ensp": " ",
+		"Eogon": "Ę",
+		"eogon": "ę",
+		"Eopf": "𝔼",
+		"eopf": "𝕖",
+		"epar": "⋕",
+		"eparsl": "⧣",
+		"eplus": "⩱",
+		"epsi": "ε",
+		"Epsilon": "Ε",
+		"epsilon": "ε",
+		"epsiv": "ϵ",
+		"eqcirc": "≖",
+		"eqcolon": "≕",
+		"eqsim": "≂",
+		"eqslantgtr": "⪖",
+		"eqslantless": "⪕",
+		"Equal": "⩵",
+		"equals": "=",
+		"EqualTilde": "≂",
+		"equest": "≟",
+		"Equilibrium": "⇌",
+		"equiv": "≡",
+		"equivDD": "⩸",
+		"eqvparsl": "⧥",
+		"erarr": "⥱",
+		"erDot": "≓",
+		"escr": "ℯ",
+		"Escr": "ℰ",
+		"esdot": "≐",
+		"Esim": "⩳",
+		"esim": "≂",
+		"Eta": "Η",
+		"eta": "η",
+		"ETH": "Ð",
+		"eth": "ð",
+		"Euml": "Ë",
+		"euml": "ë",
+		"euro": "€",
+		"excl": "!",
+		"exist": "∃",
+		"Exists": "∃",
+		"expectation": "ℰ",
+		"exponentiale": "ⅇ",
+		"ExponentialE": "ⅇ",
+		"fallingdotseq": "≒",
+		"Fcy": "Ф",
+		"fcy": "ф",
+		"female": "♀",
+		"ffilig": "ffi",
+		"fflig": "ff",
+		"ffllig": "ffl",
+		"Ffr": "𝔉",
+		"ffr": "𝔣",
+		"filig": "fi",
+		"FilledSmallSquare": "◼",
+		"FilledVerySmallSquare": "▪",
+		"fjlig": "fj",
+		"flat": "♭",
+		"fllig": "fl",
+		"fltns": "▱",
+		"fnof": "ƒ",
+		"Fopf": "𝔽",
+		"fopf": "𝕗",
+		"forall": "∀",
+		"ForAll": "∀",
+		"fork": "⋔",
+		"forkv": "⫙",
+		"Fouriertrf": "ℱ",
+		"fpartint": "⨍",
+		"frac12": "½",
+		"frac13": "⅓",
+		"frac14": "¼",
+		"frac15": "⅕",
+		"frac16": "⅙",
+		"frac18": "⅛",
+		"frac23": "⅔",
+		"frac25": "⅖",
+		"frac34": "¾",
+		"frac35": "⅗",
+		"frac38": "⅜",
+		"frac45": "⅘",
+		"frac56": "⅚",
+		"frac58": "⅝",
+		"frac78": "⅞",
+		"frasl": "⁄",
+		"frown": "⌢",
+		"fscr": "𝒻",
+		"Fscr": "ℱ",
+		"gacute": "ǵ",
+		"Gamma": "Γ",
+		"gamma": "γ",
+		"Gammad": "Ϝ",
+		"gammad": "ϝ",
+		"gap": "⪆",
+		"Gbreve": "Ğ",
+		"gbreve": "ğ",
+		"Gcedil": "Ģ",
+		"Gcirc": "Ĝ",
+		"gcirc": "ĝ",
+		"Gcy": "Г",
+		"gcy": "г",
+		"Gdot": "Ġ",
+		"gdot": "ġ",
+		"ge": "≥",
+		"gE": "≧",
+		"gEl": "⪌",
+		"gel": "⋛",
+		"geq": "≥",
+		"geqq": "≧",
+		"geqslant": "⩾",
+		"gescc": "⪩",
+		"ges": "⩾",
+		"gesdot": "⪀",
+		"gesdoto": "⪂",
+		"gesdotol": "⪄",
+		"gesl": "⋛︀",
+		"gesles": "⪔",
+		"Gfr": "𝔊",
+		"gfr": "𝔤",
+		"gg": "≫",
+		"Gg": "⋙",
+		"ggg": "⋙",
+		"gimel": "ℷ",
+		"GJcy": "Ѓ",
+		"gjcy": "ѓ",
+		"gla": "⪥",
+		"gl": "≷",
+		"glE": "⪒",
+		"glj": "⪤",
+		"gnap": "⪊",
+		"gnapprox": "⪊",
+		"gne": "⪈",
+		"gnE": "≩",
+		"gneq": "⪈",
+		"gneqq": "≩",
+		"gnsim": "⋧",
+		"Gopf": "𝔾",
+		"gopf": "𝕘",
+		"grave": "`",
+		"GreaterEqual": "≥",
+		"GreaterEqualLess": "⋛",
+		"GreaterFullEqual": "≧",
+		"GreaterGreater": "⪢",
+		"GreaterLess": "≷",
+		"GreaterSlantEqual": "⩾",
+		"GreaterTilde": "≳",
+		"Gscr": "𝒢",
+		"gscr": "ℊ",
+		"gsim": "≳",
+		"gsime": "⪎",
+		"gsiml": "⪐",
+		"gtcc": "⪧",
+		"gtcir": "⩺",
+		"gt": ">",
+		"GT": ">",
+		"Gt": "≫",
+		"gtdot": "⋗",
+		"gtlPar": "⦕",
+		"gtquest": "⩼",
+		"gtrapprox": "⪆",
+		"gtrarr": "⥸",
+		"gtrdot": "⋗",
+		"gtreqless": "⋛",
+		"gtreqqless": "⪌",
+		"gtrless": "≷",
+		"gtrsim": "≳",
+		"gvertneqq": "≩︀",
+		"gvnE": "≩︀",
+		"Hacek": "ˇ",
+		"hairsp": " ",
+		"half": "½",
+		"hamilt": "ℋ",
+		"HARDcy": "Ъ",
+		"hardcy": "ъ",
+		"harrcir": "⥈",
+		"harr": "↔",
+		"hArr": "⇔",
+		"harrw": "↭",
+		"Hat": "^",
+		"hbar": "ℏ",
+		"Hcirc": "Ĥ",
+		"hcirc": "ĥ",
+		"hearts": "♥",
+		"heartsuit": "♥",
+		"hellip": "…",
+		"hercon": "⊹",
+		"hfr": "𝔥",
+		"Hfr": "ℌ",
+		"HilbertSpace": "ℋ",
+		"hksearow": "⤥",
+		"hkswarow": "⤦",
+		"hoarr": "⇿",
+		"homtht": "∻",
+		"hookleftarrow": "↩",
+		"hookrightarrow": "↪",
+		"hopf": "𝕙",
+		"Hopf": "ℍ",
+		"horbar": "―",
+		"HorizontalLine": "─",
+		"hscr": "𝒽",
+		"Hscr": "ℋ",
+		"hslash": "ℏ",
+		"Hstrok": "Ħ",
+		"hstrok": "ħ",
+		"HumpDownHump": "≎",
+		"HumpEqual": "≏",
+		"hybull": "⁃",
+		"hyphen": "‐",
+		"Iacute": "Í",
+		"iacute": "í",
+		"ic": "⁣",
+		"Icirc": "Î",
+		"icirc": "î",
+		"Icy": "И",
+		"icy": "и",
+		"Idot": "İ",
+		"IEcy": "Е",
+		"iecy": "е",
+		"iexcl": "¡",
+		"iff": "⇔",
+		"ifr": "𝔦",
+		"Ifr": "ℑ",
+		"Igrave": "Ì",
+		"igrave": "ì",
+		"ii": "ⅈ",
+		"iiiint": "⨌",
+		"iiint": "∭",
+		"iinfin": "⧜",
+		"iiota": "℩",
+		"IJlig": "IJ",
+		"ijlig": "ij",
+		"Imacr": "Ī",
+		"imacr": "ī",
+		"image": "ℑ",
+		"ImaginaryI": "ⅈ",
+		"imagline": "ℐ",
+		"imagpart": "ℑ",
+		"imath": "ı",
+		"Im": "ℑ",
+		"imof": "⊷",
+		"imped": "Ƶ",
+		"Implies": "⇒",
+		"incare": "℅",
+		"in": "∈",
+		"infin": "∞",
+		"infintie": "⧝",
+		"inodot": "ı",
+		"intcal": "⊺",
+		"int": "∫",
+		"Int": "∬",
+		"integers": "ℤ",
+		"Integral": "∫",
+		"intercal": "⊺",
+		"Intersection": "⋂",
+		"intlarhk": "⨗",
+		"intprod": "⨼",
+		"InvisibleComma": "⁣",
+		"InvisibleTimes": "⁢",
+		"IOcy": "Ё",
+		"iocy": "ё",
+		"Iogon": "Į",
+		"iogon": "į",
+		"Iopf": "𝕀",
+		"iopf": "𝕚",
+		"Iota": "Ι",
+		"iota": "ι",
+		"iprod": "⨼",
+		"iquest": "¿",
+		"iscr": "𝒾",
+		"Iscr": "ℐ",
+		"isin": "∈",
+		"isindot": "⋵",
+		"isinE": "⋹",
+		"isins": "⋴",
+		"isinsv": "⋳",
+		"isinv": "∈",
+		"it": "⁢",
+		"Itilde": "Ĩ",
+		"itilde": "ĩ",
+		"Iukcy": "І",
+		"iukcy": "і",
+		"Iuml": "Ï",
+		"iuml": "ï",
+		"Jcirc": "Ĵ",
+		"jcirc": "ĵ",
+		"Jcy": "Й",
+		"jcy": "й",
+		"Jfr": "𝔍",
+		"jfr": "𝔧",
+		"jmath": "ȷ",
+		"Jopf": "𝕁",
+		"jopf": "𝕛",
+		"Jscr": "𝒥",
+		"jscr": "𝒿",
+		"Jsercy": "Ј",
+		"jsercy": "ј",
+		"Jukcy": "Є",
+		"jukcy": "є",
+		"Kappa": "Κ",
+		"kappa": "κ",
+		"kappav": "ϰ",
+		"Kcedil": "Ķ",
+		"kcedil": "ķ",
+		"Kcy": "К",
+		"kcy": "к",
+		"Kfr": "𝔎",
+		"kfr": "𝔨",
+		"kgreen": "ĸ",
+		"KHcy": "Х",
+		"khcy": "х",
+		"KJcy": "Ќ",
+		"kjcy": "ќ",
+		"Kopf": "𝕂",
+		"kopf": "𝕜",
+		"Kscr": "𝒦",
+		"kscr": "𝓀",
+		"lAarr": "⇚",
+		"Lacute": "Ĺ",
+		"lacute": "ĺ",
+		"laemptyv": "⦴",
+		"lagran": "ℒ",
+		"Lambda": "Λ",
+		"lambda": "λ",
+		"lang": "⟨",
+		"Lang": "⟪",
+		"langd": "⦑",
+		"langle": "⟨",
+		"lap": "⪅",
+		"Laplacetrf": "ℒ",
+		"laquo": "«",
+		"larrb": "⇤",
+		"larrbfs": "⤟",
+		"larr": "←",
+		"Larr": "↞",
+		"lArr": "⇐",
+		"larrfs": "⤝",
+		"larrhk": "↩",
+		"larrlp": "↫",
+		"larrpl": "⤹",
+		"larrsim": "⥳",
+		"larrtl": "↢",
+		"latail": "⤙",
+		"lAtail": "⤛",
+		"lat": "⪫",
+		"late": "⪭",
+		"lates": "⪭︀",
+		"lbarr": "⤌",
+		"lBarr": "⤎",
+		"lbbrk": "❲",
+		"lbrace": "{",
+		"lbrack": "[",
+		"lbrke": "⦋",
+		"lbrksld": "⦏",
+		"lbrkslu": "⦍",
+		"Lcaron": "Ľ",
+		"lcaron": "ľ",
+		"Lcedil": "Ļ",
+		"lcedil": "ļ",
+		"lceil": "⌈",
+		"lcub": "{",
+		"Lcy": "Л",
+		"lcy": "л",
+		"ldca": "⤶",
+		"ldquo": "“",
+		"ldquor": "„",
+		"ldrdhar": "⥧",
+		"ldrushar": "⥋",
+		"ldsh": "↲",
+		"le": "≤",
+		"lE": "≦",
+		"LeftAngleBracket": "⟨",
+		"LeftArrowBar": "⇤",
+		"leftarrow": "←",
+		"LeftArrow": "←",
+		"Leftarrow": "⇐",
+		"LeftArrowRightArrow": "⇆",
+		"leftarrowtail": "↢",
+		"LeftCeiling": "⌈",
+		"LeftDoubleBracket": "⟦",
+		"LeftDownTeeVector": "⥡",
+		"LeftDownVectorBar": "⥙",
+		"LeftDownVector": "⇃",
+		"LeftFloor": "⌊",
+		"leftharpoondown": "↽",
+		"leftharpoonup": "↼",
+		"leftleftarrows": "⇇",
+		"leftrightarrow": "↔",
+		"LeftRightArrow": "↔",
+		"Leftrightarrow": "⇔",
+		"leftrightarrows": "⇆",
+		"leftrightharpoons": "⇋",
+		"leftrightsquigarrow": "↭",
+		"LeftRightVector": "⥎",
+		"LeftTeeArrow": "↤",
+		"LeftTee": "⊣",
+		"LeftTeeVector": "⥚",
+		"leftthreetimes": "⋋",
+		"LeftTriangleBar": "⧏",
+		"LeftTriangle": "⊲",
+		"LeftTriangleEqual": "⊴",
+		"LeftUpDownVector": "⥑",
+		"LeftUpTeeVector": "⥠",
+		"LeftUpVectorBar": "⥘",
+		"LeftUpVector": "↿",
+		"LeftVectorBar": "⥒",
+		"LeftVector": "↼",
+		"lEg": "⪋",
+		"leg": "⋚",
+		"leq": "≤",
+		"leqq": "≦",
+		"leqslant": "⩽",
+		"lescc": "⪨",
+		"les": "⩽",
+		"lesdot": "⩿",
+		"lesdoto": "⪁",
+		"lesdotor": "⪃",
+		"lesg": "⋚︀",
+		"lesges": "⪓",
+		"lessapprox": "⪅",
+		"lessdot": "⋖",
+		"lesseqgtr": "⋚",
+		"lesseqqgtr": "⪋",
+		"LessEqualGreater": "⋚",
+		"LessFullEqual": "≦",
+		"LessGreater": "≶",
+		"lessgtr": "≶",
+		"LessLess": "⪡",
+		"lesssim": "≲",
+		"LessSlantEqual": "⩽",
+		"LessTilde": "≲",
+		"lfisht": "⥼",
+		"lfloor": "⌊",
+		"Lfr": "𝔏",
+		"lfr": "𝔩",
+		"lg": "≶",
+		"lgE": "⪑",
+		"lHar": "⥢",
+		"lhard": "↽",
+		"lharu": "↼",
+		"lharul": "⥪",
+		"lhblk": "▄",
+		"LJcy": "Љ",
+		"ljcy": "љ",
+		"llarr": "⇇",
+		"ll": "≪",
+		"Ll": "⋘",
+		"llcorner": "⌞",
+		"Lleftarrow": "⇚",
+		"llhard": "⥫",
+		"lltri": "◺",
+		"Lmidot": "Ŀ",
+		"lmidot": "ŀ",
+		"lmoustache": "⎰",
+		"lmoust": "⎰",
+		"lnap": "⪉",
+		"lnapprox": "⪉",
+		"lne": "⪇",
+		"lnE": "≨",
+		"lneq": "⪇",
+		"lneqq": "≨",
+		"lnsim": "⋦",
+		"loang": "⟬",
+		"loarr": "⇽",
+		"lobrk": "⟦",
+		"longleftarrow": "⟵",
+		"LongLeftArrow": "⟵",
+		"Longleftarrow": "⟸",
+		"longleftrightarrow": "⟷",
+		"LongLeftRightArrow": "⟷",
+		"Longleftrightarrow": "⟺",
+		"longmapsto": "⟼",
+		"longrightarrow": "⟶",
+		"LongRightArrow": "⟶",
+		"Longrightarrow": "⟹",
+		"looparrowleft": "↫",
+		"looparrowright": "↬",
+		"lopar": "⦅",
+		"Lopf": "𝕃",
+		"lopf": "𝕝",
+		"loplus": "⨭",
+		"lotimes": "⨴",
+		"lowast": "∗",
+		"lowbar": "_",
+		"LowerLeftArrow": "↙",
+		"LowerRightArrow": "↘",
+		"loz": "◊",
+		"lozenge": "◊",
+		"lozf": "⧫",
+		"lpar": "(",
+		"lparlt": "⦓",
+		"lrarr": "⇆",
+		"lrcorner": "⌟",
+		"lrhar": "⇋",
+		"lrhard": "⥭",
+		"lrm": "‎",
+		"lrtri": "⊿",
+		"lsaquo": "‹",
+		"lscr": "𝓁",
+		"Lscr": "ℒ",
+		"lsh": "↰",
+		"Lsh": "↰",
+		"lsim": "≲",
+		"lsime": "⪍",
+		"lsimg": "⪏",
+		"lsqb": "[",
+		"lsquo": "‘",
+		"lsquor": "‚",
+		"Lstrok": "Ł",
+		"lstrok": "ł",
+		"ltcc": "⪦",
+		"ltcir": "⩹",
+		"lt": "<",
+		"LT": "<",
+		"Lt": "≪",
+		"ltdot": "⋖",
+		"lthree": "⋋",
+		"ltimes": "⋉",
+		"ltlarr": "⥶",
+		"ltquest": "⩻",
+		"ltri": "◃",
+		"ltrie": "⊴",
+		"ltrif": "◂",
+		"ltrPar": "⦖",
+		"lurdshar": "⥊",
+		"luruhar": "⥦",
+		"lvertneqq": "≨︀",
+		"lvnE": "≨︀",
+		"macr": "¯",
+		"male": "♂",
+		"malt": "✠",
+		"maltese": "✠",
+		"Map": "⤅",
+		"map": "↦",
+		"mapsto": "↦",
+		"mapstodown": "↧",
+		"mapstoleft": "↤",
+		"mapstoup": "↥",
+		"marker": "▮",
+		"mcomma": "⨩",
+		"Mcy": "М",
+		"mcy": "м",
+		"mdash": "—",
+		"mDDot": "∺",
+		"measuredangle": "∡",
+		"MediumSpace": " ",
+		"Mellintrf": "ℳ",
+		"Mfr": "𝔐",
+		"mfr": "𝔪",
+		"mho": "℧",
+		"micro": "µ",
+		"midast": "*",
+		"midcir": "⫰",
+		"mid": "∣",
+		"middot": "·",
+		"minusb": "⊟",
+		"minus": "−",
+		"minusd": "∸",
+		"minusdu": "⨪",
+		"MinusPlus": "∓",
+		"mlcp": "⫛",
+		"mldr": "…",
+		"mnplus": "∓",
+		"models": "⊧",
+		"Mopf": "𝕄",
+		"mopf": "𝕞",
+		"mp": "∓",
+		"mscr": "𝓂",
+		"Mscr": "ℳ",
+		"mstpos": "∾",
+		"Mu": "Μ",
+		"mu": "μ",
+		"multimap": "⊸",
+		"mumap": "⊸",
+		"nabla": "∇",
+		"Nacute": "Ń",
+		"nacute": "ń",
+		"nang": "∠⃒",
+		"nap": "≉",
+		"napE": "⩰̸",
+		"napid": "≋̸",
+		"napos": "ʼn",
+		"napprox": "≉",
+		"natural": "♮",
+		"naturals": "ℕ",
+		"natur": "♮",
+		"nbsp": " ",
+		"nbump": "≎̸",
+		"nbumpe": "≏̸",
+		"ncap": "⩃",
+		"Ncaron": "Ň",
+		"ncaron": "ň",
+		"Ncedil": "Ņ",
+		"ncedil": "ņ",
+		"ncong": "≇",
+		"ncongdot": "⩭̸",
+		"ncup": "⩂",
+		"Ncy": "Н",
+		"ncy": "н",
+		"ndash": "–",
+		"nearhk": "⤤",
+		"nearr": "↗",
+		"neArr": "⇗",
+		"nearrow": "↗",
+		"ne": "≠",
+		"nedot": "≐̸",
+		"NegativeMediumSpace": "​",
+		"NegativeThickSpace": "​",
+		"NegativeThinSpace": "​",
+		"NegativeVeryThinSpace": "​",
+		"nequiv": "≢",
+		"nesear": "⤨",
+		"nesim": "≂̸",
+		"NestedGreaterGreater": "≫",
+		"NestedLessLess": "≪",
+		"NewLine": "\n",
+		"nexist": "∄",
+		"nexists": "∄",
+		"Nfr": "𝔑",
+		"nfr": "𝔫",
+		"ngE": "≧̸",
+		"nge": "≱",
+		"ngeq": "≱",
+		"ngeqq": "≧̸",
+		"ngeqslant": "⩾̸",
+		"nges": "⩾̸",
+		"nGg": "⋙̸",
+		"ngsim": "≵",
+		"nGt": "≫⃒",
+		"ngt": "≯",
+		"ngtr": "≯",
+		"nGtv": "≫̸",
+		"nharr": "↮",
+		"nhArr": "⇎",
+		"nhpar": "⫲",
+		"ni": "∋",
+		"nis": "⋼",
+		"nisd": "⋺",
+		"niv": "∋",
+		"NJcy": "Њ",
+		"njcy": "њ",
+		"nlarr": "↚",
+		"nlArr": "⇍",
+		"nldr": "‥",
+		"nlE": "≦̸",
+		"nle": "≰",
+		"nleftarrow": "↚",
+		"nLeftarrow": "⇍",
+		"nleftrightarrow": "↮",
+		"nLeftrightarrow": "⇎",
+		"nleq": "≰",
+		"nleqq": "≦̸",
+		"nleqslant": "⩽̸",
+		"nles": "⩽̸",
+		"nless": "≮",
+		"nLl": "⋘̸",
+		"nlsim": "≴",
+		"nLt": "≪⃒",
+		"nlt": "≮",
+		"nltri": "⋪",
+		"nltrie": "⋬",
+		"nLtv": "≪̸",
+		"nmid": "∤",
+		"NoBreak": "⁠",
+		"NonBreakingSpace": " ",
+		"nopf": "𝕟",
+		"Nopf": "ℕ",
+		"Not": "⫬",
+		"not": "¬",
+		"NotCongruent": "≢",
+		"NotCupCap": "≭",
+		"NotDoubleVerticalBar": "∦",
+		"NotElement": "∉",
+		"NotEqual": "≠",
+		"NotEqualTilde": "≂̸",
+		"NotExists": "∄",
+		"NotGreater": "≯",
+		"NotGreaterEqual": "≱",
+		"NotGreaterFullEqual": "≧̸",
+		"NotGreaterGreater": "≫̸",
+		"NotGreaterLess": "≹",
+		"NotGreaterSlantEqual": "⩾̸",
+		"NotGreaterTilde": "≵",
+		"NotHumpDownHump": "≎̸",
+		"NotHumpEqual": "≏̸",
+		"notin": "∉",
+		"notindot": "⋵̸",
+		"notinE": "⋹̸",
+		"notinva": "∉",
+		"notinvb": "⋷",
+		"notinvc": "⋶",
+		"NotLeftTriangleBar": "⧏̸",
+		"NotLeftTriangle": "⋪",
+		"NotLeftTriangleEqual": "⋬",
+		"NotLess": "≮",
+		"NotLessEqual": "≰",
+		"NotLessGreater": "≸",
+		"NotLessLess": "≪̸",
+		"NotLessSlantEqual": "⩽̸",
+		"NotLessTilde": "≴",
+		"NotNestedGreaterGreater": "⪢̸",
+		"NotNestedLessLess": "⪡̸",
+		"notni": "∌",
+		"notniva": "∌",
+		"notnivb": "⋾",
+		"notnivc": "⋽",
+		"NotPrecedes": "⊀",
+		"NotPrecedesEqual": "⪯̸",
+		"NotPrecedesSlantEqual": "⋠",
+		"NotReverseElement": "∌",
+		"NotRightTriangleBar": "⧐̸",
+		"NotRightTriangle": "⋫",
+		"NotRightTriangleEqual": "⋭",
+		"NotSquareSubset": "⊏̸",
+		"NotSquareSubsetEqual": "⋢",
+		"NotSquareSuperset": "⊐̸",
+		"NotSquareSupersetEqual": "⋣",
+		"NotSubset": "⊂⃒",
+		"NotSubsetEqual": "⊈",
+		"NotSucceeds": "⊁",
+		"NotSucceedsEqual": "⪰̸",
+		"NotSucceedsSlantEqual": "⋡",
+		"NotSucceedsTilde": "≿̸",
+		"NotSuperset": "⊃⃒",
+		"NotSupersetEqual": "⊉",
+		"NotTilde": "≁",
+		"NotTildeEqual": "≄",
+		"NotTildeFullEqual": "≇",
+		"NotTildeTilde": "≉",
+		"NotVerticalBar": "∤",
+		"nparallel": "∦",
+		"npar": "∦",
+		"nparsl": "⫽⃥",
+		"npart": "∂̸",
+		"npolint": "⨔",
+		"npr": "⊀",
+		"nprcue": "⋠",
+		"nprec": "⊀",
+		"npreceq": "⪯̸",
+		"npre": "⪯̸",
+		"nrarrc": "⤳̸",
+		"nrarr": "↛",
+		"nrArr": "⇏",
+		"nrarrw": "↝̸",
+		"nrightarrow": "↛",
+		"nRightarrow": "⇏",
+		"nrtri": "⋫",
+		"nrtrie": "⋭",
+		"nsc": "⊁",
+		"nsccue": "⋡",
+		"nsce": "⪰̸",
+		"Nscr": "𝒩",
+		"nscr": "𝓃",
+		"nshortmid": "∤",
+		"nshortparallel": "∦",
+		"nsim": "≁",
+		"nsime": "≄",
+		"nsimeq": "≄",
+		"nsmid": "∤",
+		"nspar": "∦",
+		"nsqsube": "⋢",
+		"nsqsupe": "⋣",
+		"nsub": "⊄",
+		"nsubE": "⫅̸",
+		"nsube": "⊈",
+		"nsubset": "⊂⃒",
+		"nsubseteq": "⊈",
+		"nsubseteqq": "⫅̸",
+		"nsucc": "⊁",
+		"nsucceq": "⪰̸",
+		"nsup": "⊅",
+		"nsupE": "⫆̸",
+		"nsupe": "⊉",
+		"nsupset": "⊃⃒",
+		"nsupseteq": "⊉",
+		"nsupseteqq": "⫆̸",
+		"ntgl": "≹",
+		"Ntilde": "Ñ",
+		"ntilde": "ñ",
+		"ntlg": "≸",
+		"ntriangleleft": "⋪",
+		"ntrianglelefteq": "⋬",
+		"ntriangleright": "⋫",
+		"ntrianglerighteq": "⋭",
+		"Nu": "Ν",
+		"nu": "ν",
+		"num": "#",
+		"numero": "№",
+		"numsp": " ",
+		"nvap": "≍⃒",
+		"nvdash": "⊬",
+		"nvDash": "⊭",
+		"nVdash": "⊮",
+		"nVDash": "⊯",
+		"nvge": "≥⃒",
+		"nvgt": ">⃒",
+		"nvHarr": "⤄",
+		"nvinfin": "⧞",
+		"nvlArr": "⤂",
+		"nvle": "≤⃒",
+		"nvlt": "<⃒",
+		"nvltrie": "⊴⃒",
+		"nvrArr": "⤃",
+		"nvrtrie": "⊵⃒",
+		"nvsim": "∼⃒",
+		"nwarhk": "⤣",
+		"nwarr": "↖",
+		"nwArr": "⇖",
+		"nwarrow": "↖",
+		"nwnear": "⤧",
+		"Oacute": "Ó",
+		"oacute": "ó",
+		"oast": "⊛",
+		"Ocirc": "Ô",
+		"ocirc": "ô",
+		"ocir": "⊚",
+		"Ocy": "О",
+		"ocy": "о",
+		"odash": "⊝",
+		"Odblac": "Ő",
+		"odblac": "ő",
+		"odiv": "⨸",
+		"odot": "⊙",
+		"odsold": "⦼",
+		"OElig": "Œ",
+		"oelig": "œ",
+		"ofcir": "⦿",
+		"Ofr": "𝔒",
+		"ofr": "𝔬",
+		"ogon": "˛",
+		"Ograve": "Ò",
+		"ograve": "ò",
+		"ogt": "⧁",
+		"ohbar": "⦵",
+		"ohm": "Ω",
+		"oint": "∮",
+		"olarr": "↺",
+		"olcir": "⦾",
+		"olcross": "⦻",
+		"oline": "‾",
+		"olt": "⧀",
+		"Omacr": "Ō",
+		"omacr": "ō",
+		"Omega": "Ω",
+		"omega": "ω",
+		"Omicron": "Ο",
+		"omicron": "ο",
+		"omid": "⦶",
+		"ominus": "⊖",
+		"Oopf": "𝕆",
+		"oopf": "𝕠",
+		"opar": "⦷",
+		"OpenCurlyDoubleQuote": "“",
+		"OpenCurlyQuote": "‘",
+		"operp": "⦹",
+		"oplus": "⊕",
+		"orarr": "↻",
+		"Or": "⩔",
+		"or": "∨",
+		"ord": "⩝",
+		"order": "ℴ",
+		"orderof": "ℴ",
+		"ordf": "ª",
+		"ordm": "º",
+		"origof": "⊶",
+		"oror": "⩖",
+		"orslope": "⩗",
+		"orv": "⩛",
+		"oS": "Ⓢ",
+		"Oscr": "𝒪",
+		"oscr": "ℴ",
+		"Oslash": "Ø",
+		"oslash": "ø",
+		"osol": "⊘",
+		"Otilde": "Õ",
+		"otilde": "õ",
+		"otimesas": "⨶",
+		"Otimes": "⨷",
+		"otimes": "⊗",
+		"Ouml": "Ö",
+		"ouml": "ö",
+		"ovbar": "⌽",
+		"OverBar": "‾",
+		"OverBrace": "⏞",
+		"OverBracket": "⎴",
+		"OverParenthesis": "⏜",
+		"para": "¶",
+		"parallel": "∥",
+		"par": "∥",
+		"parsim": "⫳",
+		"parsl": "⫽",
+		"part": "∂",
+		"PartialD": "∂",
+		"Pcy": "П",
+		"pcy": "п",
+		"percnt": "%",
+		"period": ".",
+		"permil": "‰",
+		"perp": "⊥",
+		"pertenk": "‱",
+		"Pfr": "𝔓",
+		"pfr": "𝔭",
+		"Phi": "Φ",
+		"phi": "φ",
+		"phiv": "ϕ",
+		"phmmat": "ℳ",
+		"phone": "☎",
+		"Pi": "Π",
+		"pi": "π",
+		"pitchfork": "⋔",
+		"piv": "ϖ",
+		"planck": "ℏ",
+		"planckh": "ℎ",
+		"plankv": "ℏ",
+		"plusacir": "⨣",
+		"plusb": "⊞",
+		"pluscir": "⨢",
+		"plus": "+",
+		"plusdo": "∔",
+		"plusdu": "⨥",
+		"pluse": "⩲",
+		"PlusMinus": "±",
+		"plusmn": "±",
+		"plussim": "⨦",
+		"plustwo": "⨧",
+		"pm": "±",
+		"Poincareplane": "ℌ",
+		"pointint": "⨕",
+		"popf": "𝕡",
+		"Popf": "ℙ",
+		"pound": "£",
+		"prap": "⪷",
+		"Pr": "⪻",
+		"pr": "≺",
+		"prcue": "≼",
+		"precapprox": "⪷",
+		"prec": "≺",
+		"preccurlyeq": "≼",
+		"Precedes": "≺",
+		"PrecedesEqual": "⪯",
+		"PrecedesSlantEqual": "≼",
+		"PrecedesTilde": "≾",
+		"preceq": "⪯",
+		"precnapprox": "⪹",
+		"precneqq": "⪵",
+		"precnsim": "⋨",
+		"pre": "⪯",
+		"prE": "⪳",
+		"precsim": "≾",
+		"prime": "′",
+		"Prime": "″",
+		"primes": "ℙ",
+		"prnap": "⪹",
+		"prnE": "⪵",
+		"prnsim": "⋨",
+		"prod": "∏",
+		"Product": "∏",
+		"profalar": "⌮",
+		"profline": "⌒",
+		"profsurf": "⌓",
+		"prop": "∝",
+		"Proportional": "∝",
+		"Proportion": "∷",
+		"propto": "∝",
+		"prsim": "≾",
+		"prurel": "⊰",
+		"Pscr": "𝒫",
+		"pscr": "𝓅",
+		"Psi": "Ψ",
+		"psi": "ψ",
+		"puncsp": " ",
+		"Qfr": "𝔔",
+		"qfr": "𝔮",
+		"qint": "⨌",
+		"qopf": "𝕢",
+		"Qopf": "ℚ",
+		"qprime": "⁗",
+		"Qscr": "𝒬",
+		"qscr": "𝓆",
+		"quaternions": "ℍ",
+		"quatint": "⨖",
+		"quest": "?",
+		"questeq": "≟",
+		"quot": "\"",
+		"QUOT": "\"",
+		"rAarr": "⇛",
+		"race": "∽̱",
+		"Racute": "Ŕ",
+		"racute": "ŕ",
+		"radic": "√",
+		"raemptyv": "⦳",
+		"rang": "⟩",
+		"Rang": "⟫",
+		"rangd": "⦒",
+		"range": "⦥",
+		"rangle": "⟩",
+		"raquo": "»",
+		"rarrap": "⥵",
+		"rarrb": "⇥",
+		"rarrbfs": "⤠",
+		"rarrc": "⤳",
+		"rarr": "→",
+		"Rarr": "↠",
+		"rArr": "⇒",
+		"rarrfs": "⤞",
+		"rarrhk": "↪",
+		"rarrlp": "↬",
+		"rarrpl": "⥅",
+		"rarrsim": "⥴",
+		"Rarrtl": "⤖",
+		"rarrtl": "↣",
+		"rarrw": "↝",
+		"ratail": "⤚",
+		"rAtail": "⤜",
+		"ratio": "∶",
+		"rationals": "ℚ",
+		"rbarr": "⤍",
+		"rBarr": "⤏",
+		"RBarr": "⤐",
+		"rbbrk": "❳",
+		"rbrace": "}",
+		"rbrack": "]",
+		"rbrke": "⦌",
+		"rbrksld": "⦎",
+		"rbrkslu": "⦐",
+		"Rcaron": "Ř",
+		"rcaron": "ř",
+		"Rcedil": "Ŗ",
+		"rcedil": "ŗ",
+		"rceil": "⌉",
+		"rcub": "}",
+		"Rcy": "Р",
+		"rcy": "р",
+		"rdca": "⤷",
+		"rdldhar": "⥩",
+		"rdquo": "”",
+		"rdquor": "”",
+		"rdsh": "↳",
+		"real": "ℜ",
+		"realine": "ℛ",
+		"realpart": "ℜ",
+		"reals": "ℝ",
+		"Re": "ℜ",
+		"rect": "▭",
+		"reg": "®",
+		"REG": "®",
+		"ReverseElement": "∋",
+		"ReverseEquilibrium": "⇋",
+		"ReverseUpEquilibrium": "⥯",
+		"rfisht": "⥽",
+		"rfloor": "⌋",
+		"rfr": "𝔯",
+		"Rfr": "ℜ",
+		"rHar": "⥤",
+		"rhard": "⇁",
+		"rharu": "⇀",
+		"rharul": "⥬",
+		"Rho": "Ρ",
+		"rho": "ρ",
+		"rhov": "ϱ",
+		"RightAngleBracket": "⟩",
+		"RightArrowBar": "⇥",
+		"rightarrow": "→",
+		"RightArrow": "→",
+		"Rightarrow": "⇒",
+		"RightArrowLeftArrow": "⇄",
+		"rightarrowtail": "↣",
+		"RightCeiling": "⌉",
+		"RightDoubleBracket": "⟧",
+		"RightDownTeeVector": "⥝",
+		"RightDownVectorBar": "⥕",
+		"RightDownVector": "⇂",
+		"RightFloor": "⌋",
+		"rightharpoondown": "⇁",
+		"rightharpoonup": "⇀",
+		"rightleftarrows": "⇄",
+		"rightleftharpoons": "⇌",
+		"rightrightarrows": "⇉",
+		"rightsquigarrow": "↝",
+		"RightTeeArrow": "↦",
+		"RightTee": "⊢",
+		"RightTeeVector": "⥛",
+		"rightthreetimes": "⋌",
+		"RightTriangleBar": "⧐",
+		"RightTriangle": "⊳",
+		"RightTriangleEqual": "⊵",
+		"RightUpDownVector": "⥏",
+		"RightUpTeeVector": "⥜",
+		"RightUpVectorBar": "⥔",
+		"RightUpVector": "↾",
+		"RightVectorBar": "⥓",
+		"RightVector": "⇀",
+		"ring": "˚",
+		"risingdotseq": "≓",
+		"rlarr": "⇄",
+		"rlhar": "⇌",
+		"rlm": "‏",
+		"rmoustache": "⎱",
+		"rmoust": "⎱",
+		"rnmid": "⫮",
+		"roang": "⟭",
+		"roarr": "⇾",
+		"robrk": "⟧",
+		"ropar": "⦆",
+		"ropf": "𝕣",
+		"Ropf": "ℝ",
+		"roplus": "⨮",
+		"rotimes": "⨵",
+		"RoundImplies": "⥰",
+		"rpar": ")",
+		"rpargt": "⦔",
+		"rppolint": "⨒",
+		"rrarr": "⇉",
+		"Rrightarrow": "⇛",
+		"rsaquo": "›",
+		"rscr": "𝓇",
+		"Rscr": "ℛ",
+		"rsh": "↱",
+		"Rsh": "↱",
+		"rsqb": "]",
+		"rsquo": "’",
+		"rsquor": "’",
+		"rthree": "⋌",
+		"rtimes": "⋊",
+		"rtri": "▹",
+		"rtrie": "⊵",
+		"rtrif": "▸",
+		"rtriltri": "⧎",
+		"RuleDelayed": "⧴",
+		"ruluhar": "⥨",
+		"rx": "℞",
+		"Sacute": "Ś",
+		"sacute": "ś",
+		"sbquo": "‚",
+		"scap": "⪸",
+		"Scaron": "Š",
+		"scaron": "š",
+		"Sc": "⪼",
+		"sc": "≻",
+		"sccue": "≽",
+		"sce": "⪰",
+		"scE": "⪴",
+		"Scedil": "Ş",
+		"scedil": "ş",
+		"Scirc": "Ŝ",
+		"scirc": "ŝ",
+		"scnap": "⪺",
+		"scnE": "⪶",
+		"scnsim": "⋩",
+		"scpolint": "⨓",
+		"scsim": "≿",
+		"Scy": "С",
+		"scy": "с",
+		"sdotb": "⊡",
+		"sdot": "⋅",
+		"sdote": "⩦",
+		"searhk": "⤥",
+		"searr": "↘",
+		"seArr": "⇘",
+		"searrow": "↘",
+		"sect": "§",
+		"semi": ";",
+		"seswar": "⤩",
+		"setminus": "∖",
+		"setmn": "∖",
+		"sext": "✶",
+		"Sfr": "𝔖",
+		"sfr": "𝔰",
+		"sfrown": "⌢",
+		"sharp": "♯",
+		"SHCHcy": "Щ",
+		"shchcy": "щ",
+		"SHcy": "Ш",
+		"shcy": "ш",
+		"ShortDownArrow": "↓",
+		"ShortLeftArrow": "←",
+		"shortmid": "∣",
+		"shortparallel": "∥",
+		"ShortRightArrow": "→",
+		"ShortUpArrow": "↑",
+		"shy": "­",
+		"Sigma": "Σ",
+		"sigma": "σ",
+		"sigmaf": "ς",
+		"sigmav": "ς",
+		"sim": "∼",
+		"simdot": "⩪",
+		"sime": "≃",
+		"simeq": "≃",
+		"simg": "⪞",
+		"simgE": "⪠",
+		"siml": "⪝",
+		"simlE": "⪟",
+		"simne": "≆",
+		"simplus": "⨤",
+		"simrarr": "⥲",
+		"slarr": "←",
+		"SmallCircle": "∘",
+		"smallsetminus": "∖",
+		"smashp": "⨳",
+		"smeparsl": "⧤",
+		"smid": "∣",
+		"smile": "⌣",
+		"smt": "⪪",
+		"smte": "⪬",
+		"smtes": "⪬︀",
+		"SOFTcy": "Ь",
+		"softcy": "ь",
+		"solbar": "⌿",
+		"solb": "⧄",
+		"sol": "/",
+		"Sopf": "𝕊",
+		"sopf": "𝕤",
+		"spades": "♠",
+		"spadesuit": "♠",
+		"spar": "∥",
+		"sqcap": "⊓",
+		"sqcaps": "⊓︀",
+		"sqcup": "⊔",
+		"sqcups": "⊔︀",
+		"Sqrt": "√",
+		"sqsub": "⊏",
+		"sqsube": "⊑",
+		"sqsubset": "⊏",
+		"sqsubseteq": "⊑",
+		"sqsup": "⊐",
+		"sqsupe": "⊒",
+		"sqsupset": "⊐",
+		"sqsupseteq": "⊒",
+		"square": "□",
+		"Square": "□",
+		"SquareIntersection": "⊓",
+		"SquareSubset": "⊏",
+		"SquareSubsetEqual": "⊑",
+		"SquareSuperset": "⊐",
+		"SquareSupersetEqual": "⊒",
+		"SquareUnion": "⊔",
+		"squarf": "▪",
+		"squ": "□",
+		"squf": "▪",
+		"srarr": "→",
+		"Sscr": "𝒮",
+		"sscr": "𝓈",
+		"ssetmn": "∖",
+		"ssmile": "⌣",
+		"sstarf": "⋆",
+		"Star": "⋆",
+		"star": "☆",
+		"starf": "★",
+		"straightepsilon": "ϵ",
+		"straightphi": "ϕ",
+		"strns": "¯",
+		"sub": "⊂",
+		"Sub": "⋐",
+		"subdot": "⪽",
+		"subE": "⫅",
+		"sube": "⊆",
+		"subedot": "⫃",
+		"submult": "⫁",
+		"subnE": "⫋",
+		"subne": "⊊",
+		"subplus": "⪿",
+		"subrarr": "⥹",
+		"subset": "⊂",
+		"Subset": "⋐",
+		"subseteq": "⊆",
+		"subseteqq": "⫅",
+		"SubsetEqual": "⊆",
+		"subsetneq": "⊊",
+		"subsetneqq": "⫋",
+		"subsim": "⫇",
+		"subsub": "⫕",
+		"subsup": "⫓",
+		"succapprox": "⪸",
+		"succ": "≻",
+		"succcurlyeq": "≽",
+		"Succeeds": "≻",
+		"SucceedsEqual": "⪰",
+		"SucceedsSlantEqual": "≽",
+		"SucceedsTilde": "≿",
+		"succeq": "⪰",
+		"succnapprox": "⪺",
+		"succneqq": "⪶",
+		"succnsim": "⋩",
+		"succsim": "≿",
+		"SuchThat": "∋",
+		"sum": "∑",
+		"Sum": "∑",
+		"sung": "♪",
+		"sup1": "¹",
+		"sup2": "²",
+		"sup3": "³",
+		"sup": "⊃",
+		"Sup": "⋑",
+		"supdot": "⪾",
+		"supdsub": "⫘",
+		"supE": "⫆",
+		"supe": "⊇",
+		"supedot": "⫄",
+		"Superset": "⊃",
+		"SupersetEqual": "⊇",
+		"suphsol": "⟉",
+		"suphsub": "⫗",
+		"suplarr": "⥻",
+		"supmult": "⫂",
+		"supnE": "⫌",
+		"supne": "⊋",
+		"supplus": "⫀",
+		"supset": "⊃",
+		"Supset": "⋑",
+		"supseteq": "⊇",
+		"supseteqq": "⫆",
+		"supsetneq": "⊋",
+		"supsetneqq": "⫌",
+		"supsim": "⫈",
+		"supsub": "⫔",
+		"supsup": "⫖",
+		"swarhk": "⤦",
+		"swarr": "↙",
+		"swArr": "⇙",
+		"swarrow": "↙",
+		"swnwar": "⤪",
+		"szlig": "ß",
+		"Tab": "\t",
+		"target": "⌖",
+		"Tau": "Τ",
+		"tau": "τ",
+		"tbrk": "⎴",
+		"Tcaron": "Ť",
+		"tcaron": "ť",
+		"Tcedil": "Ţ",
+		"tcedil": "ţ",
+		"Tcy": "Т",
+		"tcy": "т",
+		"tdot": "⃛",
+		"telrec": "⌕",
+		"Tfr": "𝔗",
+		"tfr": "𝔱",
+		"there4": "∴",
+		"therefore": "∴",
+		"Therefore": "∴",
+		"Theta": "Θ",
+		"theta": "θ",
+		"thetasym": "ϑ",
+		"thetav": "ϑ",
+		"thickapprox": "≈",
+		"thicksim": "∼",
+		"ThickSpace": "  ",
+		"ThinSpace": " ",
+		"thinsp": " ",
+		"thkap": "≈",
+		"thksim": "∼",
+		"THORN": "Þ",
+		"thorn": "þ",
+		"tilde": "˜",
+		"Tilde": "∼",
+		"TildeEqual": "≃",
+		"TildeFullEqual": "≅",
+		"TildeTilde": "≈",
+		"timesbar": "⨱",
+		"timesb": "⊠",
+		"times": "×",
+		"timesd": "⨰",
+		"tint": "∭",
+		"toea": "⤨",
+		"topbot": "⌶",
+		"topcir": "⫱",
+		"top": "⊤",
+		"Topf": "𝕋",
+		"topf": "𝕥",
+		"topfork": "⫚",
+		"tosa": "⤩",
+		"tprime": "‴",
+		"trade": "™",
+		"TRADE": "™",
+		"triangle": "▵",
+		"triangledown": "▿",
+		"triangleleft": "◃",
+		"trianglelefteq": "⊴",
+		"triangleq": "≜",
+		"triangleright": "▹",
+		"trianglerighteq": "⊵",
+		"tridot": "◬",
+		"trie": "≜",
+		"triminus": "⨺",
+		"TripleDot": "⃛",
+		"triplus": "⨹",
+		"trisb": "⧍",
+		"tritime": "⨻",
+		"trpezium": "⏢",
+		"Tscr": "𝒯",
+		"tscr": "𝓉",
+		"TScy": "Ц",
+		"tscy": "ц",
+		"TSHcy": "Ћ",
+		"tshcy": "ћ",
+		"Tstrok": "Ŧ",
+		"tstrok": "ŧ",
+		"twixt": "≬",
+		"twoheadleftarrow": "↞",
+		"twoheadrightarrow": "↠",
+		"Uacute": "Ú",
+		"uacute": "ú",
+		"uarr": "↑",
+		"Uarr": "↟",
+		"uArr": "⇑",
+		"Uarrocir": "⥉",
+		"Ubrcy": "Ў",
+		"ubrcy": "ў",
+		"Ubreve": "Ŭ",
+		"ubreve": "ŭ",
+		"Ucirc": "Û",
+		"ucirc": "û",
+		"Ucy": "У",
+		"ucy": "у",
+		"udarr": "⇅",
+		"Udblac": "Ű",
+		"udblac": "ű",
+		"udhar": "⥮",
+		"ufisht": "⥾",
+		"Ufr": "𝔘",
+		"ufr": "𝔲",
+		"Ugrave": "Ù",
+		"ugrave": "ù",
+		"uHar": "⥣",
+		"uharl": "↿",
+		"uharr": "↾",
+		"uhblk": "▀",
+		"ulcorn": "⌜",
+		"ulcorner": "⌜",
+		"ulcrop": "⌏",
+		"ultri": "◸",
+		"Umacr": "Ū",
+		"umacr": "ū",
+		"uml": "¨",
+		"UnderBar": "_",
+		"UnderBrace": "⏟",
+		"UnderBracket": "⎵",
+		"UnderParenthesis": "⏝",
+		"Union": "⋃",
+		"UnionPlus": "⊎",
+		"Uogon": "Ų",
+		"uogon": "ų",
+		"Uopf": "𝕌",
+		"uopf": "𝕦",
+		"UpArrowBar": "⤒",
+		"uparrow": "↑",
+		"UpArrow": "↑",
+		"Uparrow": "⇑",
+		"UpArrowDownArrow": "⇅",
+		"updownarrow": "↕",
+		"UpDownArrow": "↕",
+		"Updownarrow": "⇕",
+		"UpEquilibrium": "⥮",
+		"upharpoonleft": "↿",
+		"upharpoonright": "↾",
+		"uplus": "⊎",
+		"UpperLeftArrow": "↖",
+		"UpperRightArrow": "↗",
+		"upsi": "υ",
+		"Upsi": "ϒ",
+		"upsih": "ϒ",
+		"Upsilon": "Υ",
+		"upsilon": "υ",
+		"UpTeeArrow": "↥",
+		"UpTee": "⊥",
+		"upuparrows": "⇈",
+		"urcorn": "⌝",
+		"urcorner": "⌝",
+		"urcrop": "⌎",
+		"Uring": "Ů",
+		"uring": "ů",
+		"urtri": "◹",
+		"Uscr": "𝒰",
+		"uscr": "𝓊",
+		"utdot": "⋰",
+		"Utilde": "Ũ",
+		"utilde": "ũ",
+		"utri": "▵",
+		"utrif": "▴",
+		"uuarr": "⇈",
+		"Uuml": "Ü",
+		"uuml": "ü",
+		"uwangle": "⦧",
+		"vangrt": "⦜",
+		"varepsilon": "ϵ",
+		"varkappa": "ϰ",
+		"varnothing": "∅",
+		"varphi": "ϕ",
+		"varpi": "ϖ",
+		"varpropto": "∝",
+		"varr": "↕",
+		"vArr": "⇕",
+		"varrho": "ϱ",
+		"varsigma": "ς",
+		"varsubsetneq": "⊊︀",
+		"varsubsetneqq": "⫋︀",
+		"varsupsetneq": "⊋︀",
+		"varsupsetneqq": "⫌︀",
+		"vartheta": "ϑ",
+		"vartriangleleft": "⊲",
+		"vartriangleright": "⊳",
+		"vBar": "⫨",
+		"Vbar": "⫫",
+		"vBarv": "⫩",
+		"Vcy": "В",
+		"vcy": "в",
+		"vdash": "⊢",
+		"vDash": "⊨",
+		"Vdash": "⊩",
+		"VDash": "⊫",
+		"Vdashl": "⫦",
+		"veebar": "⊻",
+		"vee": "∨",
+		"Vee": "⋁",
+		"veeeq": "≚",
+		"vellip": "⋮",
+		"verbar": "|",
+		"Verbar": "‖",
+		"vert": "|",
+		"Vert": "‖",
+		"VerticalBar": "∣",
+		"VerticalLine": "|",
+		"VerticalSeparator": "❘",
+		"VerticalTilde": "≀",
+		"VeryThinSpace": " ",
+		"Vfr": "𝔙",
+		"vfr": "𝔳",
+		"vltri": "⊲",
+		"vnsub": "⊂⃒",
+		"vnsup": "⊃⃒",
+		"Vopf": "𝕍",
+		"vopf": "𝕧",
+		"vprop": "∝",
+		"vrtri": "⊳",
+		"Vscr": "𝒱",
+		"vscr": "𝓋",
+		"vsubnE": "⫋︀",
+		"vsubne": "⊊︀",
+		"vsupnE": "⫌︀",
+		"vsupne": "⊋︀",
+		"Vvdash": "⊪",
+		"vzigzag": "⦚",
+		"Wcirc": "Ŵ",
+		"wcirc": "ŵ",
+		"wedbar": "⩟",
+		"wedge": "∧",
+		"Wedge": "⋀",
+		"wedgeq": "≙",
+		"weierp": "℘",
+		"Wfr": "𝔚",
+		"wfr": "𝔴",
+		"Wopf": "𝕎",
+		"wopf": "𝕨",
+		"wp": "℘",
+		"wr": "≀",
+		"wreath": "≀",
+		"Wscr": "𝒲",
+		"wscr": "𝓌",
+		"xcap": "⋂",
+		"xcirc": "◯",
+		"xcup": "⋃",
+		"xdtri": "▽",
+		"Xfr": "𝔛",
+		"xfr": "𝔵",
+		"xharr": "⟷",
+		"xhArr": "⟺",
+		"Xi": "Ξ",
+		"xi": "ξ",
+		"xlarr": "⟵",
+		"xlArr": "⟸",
+		"xmap": "⟼",
+		"xnis": "⋻",
+		"xodot": "⨀",
+		"Xopf": "𝕏",
+		"xopf": "𝕩",
+		"xoplus": "⨁",
+		"xotime": "⨂",
+		"xrarr": "⟶",
+		"xrArr": "⟹",
+		"Xscr": "𝒳",
+		"xscr": "𝓍",
+		"xsqcup": "⨆",
+		"xuplus": "⨄",
+		"xutri": "△",
+		"xvee": "⋁",
+		"xwedge": "⋀",
+		"Yacute": "Ý",
+		"yacute": "ý",
+		"YAcy": "Я",
+		"yacy": "я",
+		"Ycirc": "Ŷ",
+		"ycirc": "ŷ",
+		"Ycy": "Ы",
+		"ycy": "ы",
+		"yen": "¥",
+		"Yfr": "𝔜",
+		"yfr": "𝔶",
+		"YIcy": "Ї",
+		"yicy": "ї",
+		"Yopf": "𝕐",
+		"yopf": "𝕪",
+		"Yscr": "𝒴",
+		"yscr": "𝓎",
+		"YUcy": "Ю",
+		"yucy": "ю",
+		"yuml": "ÿ",
+		"Yuml": "Ÿ",
+		"Zacute": "Ź",
+		"zacute": "ź",
+		"Zcaron": "Ž",
+		"zcaron": "ž",
+		"Zcy": "З",
+		"zcy": "з",
+		"Zdot": "Ż",
+		"zdot": "ż",
+		"zeetrf": "ℨ",
+		"ZeroWidthSpace": "​",
+		"Zeta": "Ζ",
+		"zeta": "ζ",
+		"zfr": "𝔷",
+		"Zfr": "ℨ",
+		"ZHcy": "Ж",
+		"zhcy": "ж",
+		"zigrarr": "⇝",
+		"zopf": "𝕫",
+		"Zopf": "ℤ",
+		"Zscr": "𝒵",
+		"zscr": "𝓏",
+		"zwj": "‍",
+		"zwnj": "‌"
+	};
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"Aacute": "Á",
+		"aacute": "á",
+		"Acirc": "Â",
+		"acirc": "â",
+		"acute": "´",
+		"AElig": "Æ",
+		"aelig": "æ",
+		"Agrave": "À",
+		"agrave": "à",
+		"amp": "&",
+		"AMP": "&",
+		"Aring": "Å",
+		"aring": "å",
+		"Atilde": "Ã",
+		"atilde": "ã",
+		"Auml": "Ä",
+		"auml": "ä",
+		"brvbar": "¦",
+		"Ccedil": "Ç",
+		"ccedil": "ç",
+		"cedil": "¸",
+		"cent": "¢",
+		"copy": "©",
+		"COPY": "©",
+		"curren": "¤",
+		"deg": "°",
+		"divide": "÷",
+		"Eacute": "É",
+		"eacute": "é",
+		"Ecirc": "Ê",
+		"ecirc": "ê",
+		"Egrave": "È",
+		"egrave": "è",
+		"ETH": "Ð",
+		"eth": "ð",
+		"Euml": "Ë",
+		"euml": "ë",
+		"frac12": "½",
+		"frac14": "¼",
+		"frac34": "¾",
+		"gt": ">",
+		"GT": ">",
+		"Iacute": "Í",
+		"iacute": "í",
+		"Icirc": "Î",
+		"icirc": "î",
+		"iexcl": "¡",
+		"Igrave": "Ì",
+		"igrave": "ì",
+		"iquest": "¿",
+		"Iuml": "Ï",
+		"iuml": "ï",
+		"laquo": "«",
+		"lt": "<",
+		"LT": "<",
+		"macr": "¯",
+		"micro": "µ",
+		"middot": "·",
+		"nbsp": " ",
+		"not": "¬",
+		"Ntilde": "Ñ",
+		"ntilde": "ñ",
+		"Oacute": "Ó",
+		"oacute": "ó",
+		"Ocirc": "Ô",
+		"ocirc": "ô",
+		"Ograve": "Ò",
+		"ograve": "ò",
+		"ordf": "ª",
+		"ordm": "º",
+		"Oslash": "Ø",
+		"oslash": "ø",
+		"Otilde": "Õ",
+		"otilde": "õ",
+		"Ouml": "Ö",
+		"ouml": "ö",
+		"para": "¶",
+		"plusmn": "±",
+		"pound": "£",
+		"quot": "\"",
+		"QUOT": "\"",
+		"raquo": "»",
+		"reg": "®",
+		"REG": "®",
+		"sect": "§",
+		"shy": "­",
+		"sup1": "¹",
+		"sup2": "²",
+		"sup3": "³",
+		"szlig": "ß",
+		"THORN": "Þ",
+		"thorn": "þ",
+		"times": "×",
+		"Uacute": "Ú",
+		"uacute": "ú",
+		"Ucirc": "Û",
+		"ucirc": "û",
+		"Ugrave": "Ù",
+		"ugrave": "ù",
+		"uml": "¨",
+		"Uuml": "Ü",
+		"uuml": "ü",
+		"Yacute": "Ý",
+		"yacute": "ý",
+		"yen": "¥",
+		"yuml": "ÿ"
+	};
+
+/***/ },
+/* 15 */
+/***/ function(module, exports) {
+
+	module.exports = {
+		"amp": "&",
+		"apos": "'",
+		"gt": ">",
+		"lt": "<",
+		"quot": "\""
+	};
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var ElementType = __webpack_require__(17);
+
+	var re_whitespace = /\s+/g;
+	var NodePrototype = __webpack_require__(18);
+	var ElementPrototype = __webpack_require__(19);
+
+	function DomHandler(callback, options, elementCB){
+		if(typeof callback === "object"){
+			elementCB = options;
+			options = callback;
+			callback = null;
+		} else if(typeof options === "function"){
+			elementCB = options;
+			options = defaultOpts;
+		}
+		this._callback = callback;
+		this._options = options || defaultOpts;
+		this._elementCB = elementCB;
+		this.dom = [];
+		this._done = false;
+		this._tagStack = [];
+		this._parser = this._parser || null;
+	}
+
+	//default options
+	var defaultOpts = {
+		normalizeWhitespace: false, //Replace all whitespace with single spaces
+		withStartIndices: false, //Add startIndex properties to nodes
+	};
+
+	DomHandler.prototype.onparserinit = function(parser){
+		this._parser = parser;
+	};
+
+	//Resets the handler back to starting state
+	DomHandler.prototype.onreset = function(){
+		DomHandler.call(this, this._callback, this._options, this._elementCB);
+	};
+
+	//Signals the handler that parsing is done
+	DomHandler.prototype.onend = function(){
+		if(this._done) return;
+		this._done = true;
+		this._parser = null;
+		this._handleCallback(null);
+	};
+
+	DomHandler.prototype._handleCallback =
+	DomHandler.prototype.onerror = function(error){
+		if(typeof this._callback === "function"){
+			this._callback(error, this.dom);
+		} else {
+			if(error) throw error;
+		}
+	};
+
+	DomHandler.prototype.onclosetag = function(){
+		//if(this._tagStack.pop().name !== name) this._handleCallback(Error("Tagname didn't match!"));
+		var elem = this._tagStack.pop();
+		if(this._elementCB) this._elementCB(elem);
+	};
+
+	DomHandler.prototype._addDomElement = function(element){
+		var parent = this._tagStack[this._tagStack.length - 1];
+		var siblings = parent ? parent.children : this.dom;
+		var previousSibling = siblings[siblings.length - 1];
+
+		element.next = null;
+
+		if(this._options.withStartIndices){
+			element.startIndex = this._parser.startIndex;
+		}
+
+		if (this._options.withDomLvl1) {
+			element.__proto__ = element.type === "tag" ? ElementPrototype : NodePrototype;
+		}
+
+		if(previousSibling){
+			element.prev = previousSibling;
+			previousSibling.next = element;
+		} else {
+			element.prev = null;
+		}
+
+		siblings.push(element);
+		element.parent = parent || null;
+	};
+
+	DomHandler.prototype.onopentag = function(name, attribs){
+		var element = {
+			type: name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag,
+			name: name,
+			attribs: attribs,
+			children: []
+		};
+
+		this._addDomElement(element);
+
+		this._tagStack.push(element);
+	};
+
+	DomHandler.prototype.ontext = function(data){
+		//the ignoreWhitespace is officially dropped, but for now,
+		//it's an alias for normalizeWhitespace
+		var normalize = this._options.normalizeWhitespace || this._options.ignoreWhitespace;
+
+		var lastTag;
+
+		if(!this._tagStack.length && this.dom.length && (lastTag = this.dom[this.dom.length-1]).type === ElementType.Text){
+			if(normalize){
+				lastTag.data = (lastTag.data + data).replace(re_whitespace, " ");
+			} else {
+				lastTag.data += data;
+			}
+		} else {
+			if(
+				this._tagStack.length &&
+				(lastTag = this._tagStack[this._tagStack.length - 1]) &&
+				(lastTag = lastTag.children[lastTag.children.length - 1]) &&
+				lastTag.type === ElementType.Text
+			){
+				if(normalize){
+					lastTag.data = (lastTag.data + data).replace(re_whitespace, " ");
+				} else {
+					lastTag.data += data;
+				}
+			} else {
+				if(normalize){
+					data = data.replace(re_whitespace, " ");
+				}
+
+				this._addDomElement({
+					data: data,
+					type: ElementType.Text
+				});
+			}
+		}
+	};
+
+	DomHandler.prototype.oncomment = function(data){
+		var lastTag = this._tagStack[this._tagStack.length - 1];
+
+		if(lastTag && lastTag.type === ElementType.Comment){
+			lastTag.data += data;
+			return;
+		}
+
+		var element = {
+			data: data,
+			type: ElementType.Comment
+		};
+
+		this._addDomElement(element);
+		this._tagStack.push(element);
+	};
+
+	DomHandler.prototype.oncdatastart = function(){
+		var element = {
+			children: [{
+				data: "",
+				type: ElementType.Text
+			}],
+			type: ElementType.CDATA
+		};
+
+		this._addDomElement(element);
+		this._tagStack.push(element);
+	};
+
+	DomHandler.prototype.oncommentend = DomHandler.prototype.oncdataend = function(){
+		this._tagStack.pop();
+	};
+
+	DomHandler.prototype.onprocessinginstruction = function(name, data){
+		this._addDomElement({
+			name: name,
+			data: data,
+			type: ElementType.Directive
+		});
+	};
+
+	module.exports = DomHandler;
+
+
+/***/ },
+/* 17 */
+/***/ function(module, exports) {
+
+	//Types of elements found in the DOM
+	module.exports = {
+		Text: "text", //Text
+		Directive: "directive", //<? ... ?>
+		Comment: "comment", //<!-- ... -->
+		Script: "script", //<script> tags
+		Style: "style", //<style> tags
+		Tag: "tag", //Any tag
+		CDATA: "cdata", //<![CDATA[ ... ]]>
+		Doctype: "doctype",
+
+		isTag: function(elem){
+			return elem.type === "tag" || elem.type === "script" || elem.type === "style";
+		}
+	};
+
+
+/***/ },
+/* 18 */
+/***/ function(module, exports) {
+
+	// This object will be used as the prototype for Nodes when creating a
+	// DOM-Level-1-compliant structure.
+	var NodePrototype = module.exports = {
+		get firstChild() {
+			var children = this.children;
+			return children && children[0] || null;
+		},
+		get lastChild() {
+			var children = this.children;
+			return children && children[children.length - 1] || null;
+		},
+		get nodeType() {
+			return nodeTypes[this.type] || nodeTypes.element;
+		}
+	};
+
+	var domLvl1 = {
+		tagName: "name",
+		childNodes: "children",
+		parentNode: "parent",
+		previousSibling: "prev",
+		nextSibling: "next",
+		nodeValue: "data"
+	};
+
+	var nodeTypes = {
+		element: 1,
+		text: 3,
+		cdata: 4,
+		comment: 8
+	};
+
+	Object.keys(domLvl1).forEach(function(key) {
+		var shorthand = domLvl1[key];
+		Object.defineProperty(NodePrototype, key, {
+			get: function() {
+				return this[shorthand] || null;
+			},
+			set: function(val) {
+				this[shorthand] = val;
+				return val;
+			}
+		});
+	});
+
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// DOM-Level-1-compliant structure
+	var NodePrototype = __webpack_require__(18);
+	var ElementPrototype = module.exports = Object.create(NodePrototype);
+
+	var domLvl1 = {
+		tagName: "name"
+	};
+
+	Object.keys(domLvl1).forEach(function(key) {
+		var shorthand = domLvl1[key];
+		Object.defineProperty(ElementPrototype, key, {
+			get: function() {
+				return this[shorthand] || null;
+			},
+			set: function(val) {
+				this[shorthand] = val;
+				return val;
+			}
+		});
+	});
+
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var index = __webpack_require__(8),
+	    DomHandler = index.DomHandler,
+		DomUtils = index.DomUtils;
+
+	//TODO: make this a streamable handler
+	function FeedHandler(callback, options){
+		this.init(callback, options);
+	}
+
+	__webpack_require__(2).inherits(FeedHandler, DomHandler);
+
+	FeedHandler.prototype.init = DomHandler;
+
+	function getElements(what, where){
+		return DomUtils.getElementsByTagName(what, where, true);
+	}
+	function getOneElement(what, where){
+		return DomUtils.getElementsByTagName(what, where, true, 1)[0];
+	}
+	function fetch(what, where, recurse){
+		return DomUtils.getText(
+			DomUtils.getElementsByTagName(what, where, recurse, 1)
+		).trim();
+	}
+
+	function addConditionally(obj, prop, what, where, recurse){
+		var tmp = fetch(what, where, recurse);
+		if(tmp) obj[prop] = tmp;
+	}
+
+	var isValidFeed = function(value){
+		return value === "rss" || value === "feed" || value === "rdf:RDF";
+	};
+
+	FeedHandler.prototype.onend = function(){
+		var feed = {},
+			feedRoot = getOneElement(isValidFeed, this.dom),
+			tmp, childs;
+
+		if(feedRoot){
+			if(feedRoot.name === "feed"){
+				childs = feedRoot.children;
+
+				feed.type = "atom";
+				addConditionally(feed, "id", "id", childs);
+				addConditionally(feed, "title", "title", childs);
+				if((tmp = getOneElement("link", childs)) && (tmp = tmp.attribs) && (tmp = tmp.href)) feed.link = tmp;
+				addConditionally(feed, "description", "subtitle", childs);
+				if((tmp = fetch("updated", childs))) feed.updated = new Date(tmp);
+				addConditionally(feed, "author", "email", childs, true);
+
+				feed.items = getElements("entry", childs).map(function(item){
+					var entry = {}, tmp;
+
+					item = item.children;
+
+					addConditionally(entry, "id", "id", item);
+					addConditionally(entry, "title", "title", item);
+					if((tmp = getOneElement("link", item)) && (tmp = tmp.attribs) && (tmp = tmp.href)) entry.link = tmp;
+					if((tmp = fetch("summary", item) || fetch("content", item))) entry.description = tmp;
+					if((tmp = fetch("updated", item))) entry.pubDate = new Date(tmp);
+					return entry;
+				});
+			} else {
+				childs = getOneElement("channel", feedRoot.children).children;
+
+				feed.type = feedRoot.name.substr(0, 3);
+				feed.id = "";
+				addConditionally(feed, "title", "title", childs);
+				addConditionally(feed, "link", "link", childs);
+				addConditionally(feed, "description", "description", childs);
+				if((tmp = fetch("lastBuildDate", childs))) feed.updated = new Date(tmp);
+				addConditionally(feed, "author", "managingEditor", childs, true);
+
+				feed.items = getElements("item", feedRoot.children).map(function(item){
+					var entry = {}, tmp;
+
+					item = item.children;
+
+					addConditionally(entry, "id", "guid", item);
+					addConditionally(entry, "title", "title", item);
+					addConditionally(entry, "link", "link", item);
+					addConditionally(entry, "description", "description", item);
+					if((tmp = fetch("pubDate", item))) entry.pubDate = new Date(tmp);
+					return entry;
+				});
+			}
+		}
+		this.dom = feed;
+		DomHandler.prototype._handleCallback.call(
+			this, feedRoot ? null : Error("couldn't find root of feed")
+		);
+	};
+
+	module.exports = FeedHandler;
+
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = Stream;
+
+	var Parser = __webpack_require__(22);
+
+	function Stream(options){
+		Parser.call(this, new Cbs(this), options);
+	}
+
+	__webpack_require__(2).inherits(Stream, Parser);
+
+	Stream.prototype.readable = true;
+
+	function Cbs(scope){
+		this.scope = scope;
+	}
+
+	var EVENTS = __webpack_require__(8).EVENTS;
+
+	Object.keys(EVENTS).forEach(function(name){
+		if(EVENTS[name] === 0){
+			Cbs.prototype["on" + name] = function(){
+				this.scope.emit(name);
+			};
+		} else if(EVENTS[name] === 1){
+			Cbs.prototype["on" + name] = function(a){
+				this.scope.emit(name, a);
+			};
+		} else if(EVENTS[name] === 2){
+			Cbs.prototype["on" + name] = function(a, b){
+				this.scope.emit(name, a, b);
+			};
+		} else {
+			throw Error("wrong number of arguments!");
+		}
+	});
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = Stream;
+
+	var Parser = __webpack_require__(9),
+	    WritableStream = __webpack_require__(23).Writable || __webpack_require__(44).Writable;
+
+	function Stream(cbs, options){
+		var parser = this._parser = new Parser(cbs, options);
+
+		WritableStream.call(this, {decodeStrings: false});
+
+		this.once("finish", function(){
+			parser.end();
+		});
+	}
+
+	__webpack_require__(2).inherits(Stream, WritableStream);
+
+	WritableStream.prototype._write = function(chunk, encoding, cb){
+		this._parser.write(chunk);
+		cb();
+	};
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 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.
+
+	module.exports = Stream;
+
+	var EE = __webpack_require__(1).EventEmitter;
+	var inherits = __webpack_require__(24);
+
+	inherits(Stream, EE);
+	Stream.Readable = __webpack_require__(25);
+	Stream.Writable = __webpack_require__(40);
+	Stream.Duplex = __webpack_require__(41);
+	Stream.Transform = __webpack_require__(42);
+	Stream.PassThrough = __webpack_require__(43);
+
+	// Backwards-compat with node 0.4.x
+	Stream.Stream = Stream;
+
+
+
+	// old-style streams.  Note that the pipe method (the only relevant
+	// part of this class) is overridden in the Readable class.
+
+	function Stream() {
+	  EE.call(this);
+	}
+
+	Stream.prototype.pipe = function(dest, options) {
+	  var source = this;
+
+	  function ondata(chunk) {
+	    if (dest.writable) {
+	      if (false === dest.write(chunk) && source.pause) {
+	        source.pause();
+	      }
+	    }
+	  }
+
+	  source.on('data', ondata);
+
+	  function ondrain() {
+	    if (source.readable && source.resume) {
+	      source.resume();
+	    }
+	  }
+
+	  dest.on('drain', ondrain);
+
+	  // If the 'end' option is not supplied, dest.end() will be called when
+	  // source gets the 'end' or 'close' events.  Only dest.end() once.
+	  if (!dest._isStdio && (!options || options.end !== false)) {
+	    source.on('end', onend);
+	    source.on('close', onclose);
+	  }
+
+	  var didOnEnd = false;
+	  function onend() {
+	    if (didOnEnd) return;
+	    didOnEnd = true;
+
+	    dest.end();
+	  }
+
+
+	  function onclose() {
+	    if (didOnEnd) return;
+	    didOnEnd = true;
+
+	    if (typeof dest.destroy === 'function') dest.destroy();
+	  }
+
+	  // don't leave dangling pipes when there are errors.
+	  function onerror(er) {
+	    cleanup();
+	    if (EE.listenerCount(this, 'error') === 0) {
+	      throw er; // Unhandled stream error in pipe.
+	    }
+	  }
+
+	  source.on('error', onerror);
+	  dest.on('error', onerror);
+
+	  // remove all the event listeners that were added.
+	  function cleanup() {
+	    source.removeListener('data', ondata);
+	    dest.removeListener('drain', ondrain);
+
+	    source.removeListener('end', onend);
+	    source.removeListener('close', onclose);
+
+	    source.removeListener('error', onerror);
+	    dest.removeListener('error', onerror);
+
+	    source.removeListener('end', cleanup);
+	    source.removeListener('close', cleanup);
+
+	    dest.removeListener('close', cleanup);
+	  }
+
+	  source.on('end', cleanup);
+	  source.on('close', cleanup);
+
+	  dest.on('close', cleanup);
+
+	  dest.emit('pipe', source);
+
+	  // Allow for unix-like usage: A.pipe(B).pipe(C)
+	  return dest;
+	};
+
+
+/***/ },
+/* 24 */
+/***/ function(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
+	  }
+	}
+
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {exports = module.exports = __webpack_require__(26);
+	exports.Stream = __webpack_require__(23);
+	exports.Readable = exports;
+	exports.Writable = __webpack_require__(36);
+	exports.Duplex = __webpack_require__(35);
+	exports.Transform = __webpack_require__(38);
+	exports.PassThrough = __webpack_require__(39);
+	if (!process.browser && process.env.READABLE_STREAM === 'disable') {
+	  module.exports = __webpack_require__(23);
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {// 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.
+
+	module.exports = Readable;
+
+	/*<replacement>*/
+	var isArray = __webpack_require__(27);
+	/*</replacement>*/
+
+
+	/*<replacement>*/
+	var Buffer = __webpack_require__(28).Buffer;
+	/*</replacement>*/
+
+	Readable.ReadableState = ReadableState;
+
+	var EE = __webpack_require__(1).EventEmitter;
+
+	/*<replacement>*/
+	if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+	  return emitter.listeners(type).length;
+	};
+	/*</replacement>*/
+
+	var Stream = __webpack_require__(23);
+
+	/*<replacement>*/
+	var util = __webpack_require__(32);
+	util.inherits = __webpack_require__(33);
+	/*</replacement>*/
+
+	var StringDecoder;
+
+
+	/*<replacement>*/
+	var debug = __webpack_require__(34);
+	if (debug && debug.debuglog) {
+	  debug = debug.debuglog('stream');
+	} else {
+	  debug = function () {};
+	}
+	/*</replacement>*/
+
+
+	util.inherits(Readable, Stream);
+
+	function ReadableState(options, stream) {
+	  var Duplex = __webpack_require__(35);
+
+	  options = options || {};
+
+	  // the point at which it stops calling _read() to fill the buffer
+	  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+	  var hwm = options.highWaterMark;
+	  var defaultHwm = options.objectMode ? 16 : 16 * 1024;
+	  this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
+
+	  // cast to ints.
+	  this.highWaterMark = ~~this.highWaterMark;
+
+	  this.buffer = [];
+	  this.length = 0;
+	  this.pipes = null;
+	  this.pipesCount = 0;
+	  this.flowing = null;
+	  this.ended = false;
+	  this.endEmitted = false;
+	  this.reading = false;
+
+	  // a flag to be able to tell if the onwrite cb is called immediately,
+	  // or on a later tick.  We set this to true at first, because any
+	  // actions that shouldn't happen until "later" should generally also
+	  // not happen before the first write call.
+	  this.sync = true;
+
+	  // whenever we return null, then we set a flag to say
+	  // that we're awaiting a 'readable' event emission.
+	  this.needReadable = false;
+	  this.emittedReadable = false;
+	  this.readableListening = false;
+
+
+	  // object stream flag. Used to make read(n) ignore n and to
+	  // make all the buffer merging and length checks go away
+	  this.objectMode = !!options.objectMode;
+
+	  if (stream instanceof Duplex)
+	    this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+	  // Crypto is kind of old and crusty.  Historically, its default string
+	  // encoding is 'binary' so we have to make this configurable.
+	  // Everything else in the universe uses 'utf8', though.
+	  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+	  // when piping, we only care about 'readable' events that happen
+	  // after read()ing all the bytes and not getting any pushback.
+	  this.ranOut = false;
+
+	  // the number of writers that are awaiting a drain event in .pipe()s
+	  this.awaitDrain = 0;
+
+	  // if true, a maybeReadMore has been scheduled
+	  this.readingMore = false;
+
+	  this.decoder = null;
+	  this.encoding = null;
+	  if (options.encoding) {
+	    if (!StringDecoder)
+	      StringDecoder = __webpack_require__(37).StringDecoder;
+	    this.decoder = new StringDecoder(options.encoding);
+	    this.encoding = options.encoding;
+	  }
+	}
+
+	function Readable(options) {
+	  var Duplex = __webpack_require__(35);
+
+	  if (!(this instanceof Readable))
+	    return new Readable(options);
+
+	  this._readableState = new ReadableState(options, this);
+
+	  // legacy
+	  this.readable = true;
+
+	  Stream.call(this);
+	}
+
+	// Manually shove something into the read() buffer.
+	// This returns true if the highWaterMark has not been hit yet,
+	// similar to how Writable.write() returns true if you should
+	// write() some more.
+	Readable.prototype.push = function(chunk, encoding) {
+	  var state = this._readableState;
+
+	  if (util.isString(chunk) && !state.objectMode) {
+	    encoding = encoding || state.defaultEncoding;
+	    if (encoding !== state.encoding) {
+	      chunk = new Buffer(chunk, encoding);
+	      encoding = '';
+	    }
+	  }
+
+	  return readableAddChunk(this, state, chunk, encoding, false);
+	};
+
+	// Unshift should *always* be something directly out of read()
+	Readable.prototype.unshift = function(chunk) {
+	  var state = this._readableState;
+	  return readableAddChunk(this, state, chunk, '', true);
+	};
+
+	function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+	  var er = chunkInvalid(state, chunk);
+	  if (er) {
+	    stream.emit('error', er);
+	  } else if (util.isNullOrUndefined(chunk)) {
+	    state.reading = false;
+	    if (!state.ended)
+	      onEofChunk(stream, state);
+	  } else if (state.objectMode || chunk && chunk.length > 0) {
+	    if (state.ended && !addToFront) {
+	      var e = new Error('stream.push() after EOF');
+	      stream.emit('error', e);
+	    } else if (state.endEmitted && addToFront) {
+	      var e = new Error('stream.unshift() after end event');
+	      stream.emit('error', e);
+	    } else {
+	      if (state.decoder && !addToFront && !encoding)
+	        chunk = state.decoder.write(chunk);
+
+	      if (!addToFront)
+	        state.reading = false;
+
+	      // if we want the data now, just emit it.
+	      if (state.flowing && state.length === 0 && !state.sync) {
+	        stream.emit('data', chunk);
+	        stream.read(0);
+	      } else {
+	        // update the buffer info.
+	        state.length += state.objectMode ? 1 : chunk.length;
+	        if (addToFront)
+	          state.buffer.unshift(chunk);
+	        else
+	          state.buffer.push(chunk);
+
+	        if (state.needReadable)
+	          emitReadable(stream);
+	      }
+
+	      maybeReadMore(stream, state);
+	    }
+	  } else if (!addToFront) {
+	    state.reading = false;
+	  }
+
+	  return needMoreData(state);
+	}
+
+
+
+	// if it's past the high water mark, we can push in some more.
+	// Also, if we have no data yet, we can stand some
+	// more bytes.  This is to work around cases where hwm=0,
+	// such as the repl.  Also, if the push() triggered a
+	// readable event, and the user called read(largeNumber) such that
+	// needReadable was set, then we ought to push more, so that another
+	// 'readable' event will be triggered.
+	function needMoreData(state) {
+	  return !state.ended &&
+	         (state.needReadable ||
+	          state.length < state.highWaterMark ||
+	          state.length === 0);
+	}
+
+	// backwards compatibility.
+	Readable.prototype.setEncoding = function(enc) {
+	  if (!StringDecoder)
+	    StringDecoder = __webpack_require__(37).StringDecoder;
+	  this._readableState.decoder = new StringDecoder(enc);
+	  this._readableState.encoding = enc;
+	  return this;
+	};
+
+	// Don't raise the hwm > 128MB
+	var MAX_HWM = 0x800000;
+	function roundUpToNextPowerOf2(n) {
+	  if (n >= MAX_HWM) {
+	    n = MAX_HWM;
+	  } else {
+	    // Get the next highest power of 2
+	    n--;
+	    for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+	    n++;
+	  }
+	  return n;
+	}
+
+	function howMuchToRead(n, state) {
+	  if (state.length === 0 && state.ended)
+	    return 0;
+
+	  if (state.objectMode)
+	    return n === 0 ? 0 : 1;
+
+	  if (isNaN(n) || util.isNull(n)) {
+	    // only flow one buffer at a time
+	    if (state.flowing && state.buffer.length)
+	      return state.buffer[0].length;
+	    else
+	      return state.length;
+	  }
+
+	  if (n <= 0)
+	    return 0;
+
+	  // If we're asking for more than the target buffer level,
+	  // then raise the water mark.  Bump up to the next highest
+	  // power of 2, to prevent increasing it excessively in tiny
+	  // amounts.
+	  if (n > state.highWaterMark)
+	    state.highWaterMark = roundUpToNextPowerOf2(n);
+
+	  // don't have that much.  return null, unless we've ended.
+	  if (n > state.length) {
+	    if (!state.ended) {
+	      state.needReadable = true;
+	      return 0;
+	    } else
+	      return state.length;
+	  }
+
+	  return n;
+	}
+
+	// you can override either this method, or the async _read(n) below.
+	Readable.prototype.read = function(n) {
+	  debug('read', n);
+	  var state = this._readableState;
+	  var nOrig = n;
+
+	  if (!util.isNumber(n) || n > 0)
+	    state.emittedReadable = false;
+
+	  // if we're doing read(0) to trigger a readable event, but we
+	  // already have a bunch of data in the buffer, then just trigger
+	  // the 'readable' event and move on.
+	  if (n === 0 &&
+	      state.needReadable &&
+	      (state.length >= state.highWaterMark || state.ended)) {
+	    debug('read: emitReadable', state.length, state.ended);
+	    if (state.length === 0 && state.ended)
+	      endReadable(this);
+	    else
+	      emitReadable(this);
+	    return null;
+	  }
+
+	  n = howMuchToRead(n, state);
+
+	  // if we've ended, and we're now clear, then finish it up.
+	  if (n === 0 && state.ended) {
+	    if (state.length === 0)
+	      endReadable(this);
+	    return null;
+	  }
+
+	  // All the actual chunk generation logic needs to be
+	  // *below* the call to _read.  The reason is that in certain
+	  // synthetic stream cases, such as passthrough streams, _read
+	  // may be a completely synchronous operation which may change
+	  // the state of the read buffer, providing enough data when
+	  // before there was *not* enough.
+	  //
+	  // So, the steps are:
+	  // 1. Figure out what the state of things will be after we do
+	  // a read from the buffer.
+	  //
+	  // 2. If that resulting state will trigger a _read, then call _read.
+	  // Note that this may be asynchronous, or synchronous.  Yes, it is
+	  // deeply ugly to write APIs this way, but that still doesn't mean
+	  // that the Readable class should behave improperly, as streams are
+	  // designed to be sync/async agnostic.
+	  // Take note if the _read call is sync or async (ie, if the read call
+	  // has returned yet), so that we know whether or not it's safe to emit
+	  // 'readable' etc.
+	  //
+	  // 3. Actually pull the requested chunks out of the buffer and return.
+
+	  // if we need a readable event, then we need to do some reading.
+	  var doRead = state.needReadable;
+	  debug('need readable', doRead);
+
+	  // if we currently have less than the highWaterMark, then also read some
+	  if (state.length === 0 || state.length - n < state.highWaterMark) {
+	    doRead = true;
+	    debug('length less than watermark', doRead);
+	  }
+
+	  // however, if we've ended, then there's no point, and if we're already
+	  // reading, then it's unnecessary.
+	  if (state.ended || state.reading) {
+	    doRead = false;
+	    debug('reading or ended', doRead);
+	  }
+
+	  if (doRead) {
+	    debug('do read');
+	    state.reading = true;
+	    state.sync = true;
+	    // if the length is currently zero, then we *need* a readable event.
+	    if (state.length === 0)
+	      state.needReadable = true;
+	    // call internal read method
+	    this._read(state.highWaterMark);
+	    state.sync = false;
+	  }
+
+	  // If _read pushed data synchronously, then `reading` will be false,
+	  // and we need to re-evaluate how much data we can return to the user.
+	  if (doRead && !state.reading)
+	    n = howMuchToRead(nOrig, state);
+
+	  var ret;
+	  if (n > 0)
+	    ret = fromList(n, state);
+	  else
+	    ret = null;
+
+	  if (util.isNull(ret)) {
+	    state.needReadable = true;
+	    n = 0;
+	  }
+
+	  state.length -= n;
+
+	  // If we have nothing in the buffer, then we want to know
+	  // as soon as we *do* get something into the buffer.
+	  if (state.length === 0 && !state.ended)
+	    state.needReadable = true;
+
+	  // If we tried to read() past the EOF, then emit end on the next tick.
+	  if (nOrig !== n && state.ended && state.length === 0)
+	    endReadable(this);
+
+	  if (!util.isNull(ret))
+	    this.emit('data', ret);
+
+	  return ret;
+	};
+
+	function chunkInvalid(state, chunk) {
+	  var er = null;
+	  if (!util.isBuffer(chunk) &&
+	      !util.isString(chunk) &&
+	      !util.isNullOrUndefined(chunk) &&
+	      !state.objectMode) {
+	    er = new TypeError('Invalid non-string/buffer chunk');
+	  }
+	  return er;
+	}
+
+
+	function onEofChunk(stream, state) {
+	  if (state.decoder && !state.ended) {
+	    var chunk = state.decoder.end();
+	    if (chunk && chunk.length) {
+	      state.buffer.push(chunk);
+	      state.length += state.objectMode ? 1 : chunk.length;
+	    }
+	  }
+	  state.ended = true;
+
+	  // emit 'readable' now to make sure it gets picked up.
+	  emitReadable(stream);
+	}
+
+	// Don't emit readable right away in sync mode, because this can trigger
+	// another read() call => stack overflow.  This way, it might trigger
+	// a nextTick recursion warning, but that's not so bad.
+	function emitReadable(stream) {
+	  var state = stream._readableState;
+	  state.needReadable = false;
+	  if (!state.emittedReadable) {
+	    debug('emitReadable', state.flowing);
+	    state.emittedReadable = true;
+	    if (state.sync)
+	      process.nextTick(function() {
+	        emitReadable_(stream);
+	      });
+	    else
+	      emitReadable_(stream);
+	  }
+	}
+
+	function emitReadable_(stream) {
+	  debug('emit readable');
+	  stream.emit('readable');
+	  flow(stream);
+	}
+
+
+	// at this point, the user has presumably seen the 'readable' event,
+	// and called read() to consume some data.  that may have triggered
+	// in turn another _read(n) call, in which case reading = true if
+	// it's in progress.
+	// However, if we're not ended, or reading, and the length < hwm,
+	// then go ahead and try to read some more preemptively.
+	function maybeReadMore(stream, state) {
+	  if (!state.readingMore) {
+	    state.readingMore = true;
+	    process.nextTick(function() {
+	      maybeReadMore_(stream, state);
+	    });
+	  }
+	}
+
+	function maybeReadMore_(stream, state) {
+	  var len = state.length;
+	  while (!state.reading && !state.flowing && !state.ended &&
+	         state.length < state.highWaterMark) {
+	    debug('maybeReadMore read 0');
+	    stream.read(0);
+	    if (len === state.length)
+	      // didn't get any data, stop spinning.
+	      break;
+	    else
+	      len = state.length;
+	  }
+	  state.readingMore = false;
+	}
+
+	// abstract method.  to be overridden in specific implementation classes.
+	// call cb(er, data) where data is <= n in length.
+	// for virtual (non-string, non-buffer) streams, "length" is somewhat
+	// arbitrary, and perhaps not very meaningful.
+	Readable.prototype._read = function(n) {
+	  this.emit('error', new Error('not implemented'));
+	};
+
+	Readable.prototype.pipe = function(dest, pipeOpts) {
+	  var src = this;
+	  var state = this._readableState;
+
+	  switch (state.pipesCount) {
+	    case 0:
+	      state.pipes = dest;
+	      break;
+	    case 1:
+	      state.pipes = [state.pipes, dest];
+	      break;
+	    default:
+	      state.pipes.push(dest);
+	      break;
+	  }
+	  state.pipesCount += 1;
+	  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+	  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+	              dest !== process.stdout &&
+	              dest !== process.stderr;
+
+	  var endFn = doEnd ? onend : cleanup;
+	  if (state.endEmitted)
+	    process.nextTick(endFn);
+	  else
+	    src.once('end', endFn);
+
+	  dest.on('unpipe', onunpipe);
+	  function onunpipe(readable) {
+	    debug('onunpipe');
+	    if (readable === src) {
+	      cleanup();
+	    }
+	  }
+
+	  function onend() {
+	    debug('onend');
+	    dest.end();
+	  }
+
+	  // when the dest drains, it reduces the awaitDrain counter
+	  // on the source.  This would be more elegant with a .once()
+	  // handler in flow(), but adding and removing repeatedly is
+	  // too slow.
+	  var ondrain = pipeOnDrain(src);
+	  dest.on('drain', ondrain);
+
+	  function cleanup() {
+	    debug('cleanup');
+	    // cleanup event handlers once the pipe is broken
+	    dest.removeListener('close', onclose);
+	    dest.removeListener('finish', onfinish);
+	    dest.removeListener('drain', ondrain);
+	    dest.removeListener('error', onerror);
+	    dest.removeListener('unpipe', onunpipe);
+	    src.removeListener('end', onend);
+	    src.removeListener('end', cleanup);
+	    src.removeListener('data', ondata);
+
+	    // if the reader is waiting for a drain event from this
+	    // specific writer, then it would cause it to never start
+	    // flowing again.
+	    // So, if this is awaiting a drain, then we just call it now.
+	    // If we don't know, then assume that we are waiting for one.
+	    if (state.awaitDrain &&
+	        (!dest._writableState || dest._writableState.needDrain))
+	      ondrain();
+	  }
+
+	  src.on('data', ondata);
+	  function ondata(chunk) {
+	    debug('ondata');
+	    var ret = dest.write(chunk);
+	    if (false === ret) {
+	      debug('false write response, pause',
+	            src._readableState.awaitDrain);
+	      src._readableState.awaitDrain++;
+	      src.pause();
+	    }
+	  }
+
+	  // if the dest has an error, then stop piping into it.
+	  // however, don't suppress the throwing behavior for this.
+	  function onerror(er) {
+	    debug('onerror', er);
+	    unpipe();
+	    dest.removeListener('error', onerror);
+	    if (EE.listenerCount(dest, 'error') === 0)
+	      dest.emit('error', er);
+	  }
+	  // This is a brutally ugly hack to make sure that our error handler
+	  // is attached before any userland ones.  NEVER DO THIS.
+	  if (!dest._events || !dest._events.error)
+	    dest.on('error', onerror);
+	  else if (isArray(dest._events.error))
+	    dest._events.error.unshift(onerror);
+	  else
+	    dest._events.error = [onerror, dest._events.error];
+
+
+
+	  // Both close and finish should trigger unpipe, but only once.
+	  function onclose() {
+	    dest.removeListener('finish', onfinish);
+	    unpipe();
+	  }
+	  dest.once('close', onclose);
+	  function onfinish() {
+	    debug('onfinish');
+	    dest.removeListener('close', onclose);
+	    unpipe();
+	  }
+	  dest.once('finish', onfinish);
+
+	  function unpipe() {
+	    debug('unpipe');
+	    src.unpipe(dest);
+	  }
+
+	  // tell the dest that it's being piped to
+	  dest.emit('pipe', src);
+
+	  // start the flow if it hasn't been started already.
+	  if (!state.flowing) {
+	    debug('pipe resume');
+	    src.resume();
+	  }
+
+	  return dest;
+	};
+
+	function pipeOnDrain(src) {
+	  return function() {
+	    var state = src._readableState;
+	    debug('pipeOnDrain', state.awaitDrain);
+	    if (state.awaitDrain)
+	      state.awaitDrain--;
+	    if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) {
+	      state.flowing = true;
+	      flow(src);
+	    }
+	  };
+	}
+
+
+	Readable.prototype.unpipe = function(dest) {
+	  var state = this._readableState;
+
+	  // if we're not piping anywhere, then do nothing.
+	  if (state.pipesCount === 0)
+	    return this;
+
+	  // just one destination.  most common case.
+	  if (state.pipesCount === 1) {
+	    // passed in one, but it's not the right one.
+	    if (dest && dest !== state.pipes)
+	      return this;
+
+	    if (!dest)
+	      dest = state.pipes;
+
+	    // got a match.
+	    state.pipes = null;
+	    state.pipesCount = 0;
+	    state.flowing = false;
+	    if (dest)
+	      dest.emit('unpipe', this);
+	    return this;
+	  }
+
+	  // slow case. multiple pipe destinations.
+
+	  if (!dest) {
+	    // remove all.
+	    var dests = state.pipes;
+	    var len = state.pipesCount;
+	    state.pipes = null;
+	    state.pipesCount = 0;
+	    state.flowing = false;
+
+	    for (var i = 0; i < len; i++)
+	      dests[i].emit('unpipe', this);
+	    return this;
+	  }
+
+	  // try to find the right one.
+	  var i = indexOf(state.pipes, dest);
+	  if (i === -1)
+	    return this;
+
+	  state.pipes.splice(i, 1);
+	  state.pipesCount -= 1;
+	  if (state.pipesCount === 1)
+	    state.pipes = state.pipes[0];
+
+	  dest.emit('unpipe', this);
+
+	  return this;
+	};
+
+	// set up data events if they are asked for
+	// Ensure readable listeners eventually get something
+	Readable.prototype.on = function(ev, fn) {
+	  var res = Stream.prototype.on.call(this, ev, fn);
+
+	  // If listening to data, and it has not explicitly been paused,
+	  // then call resume to start the flow of data on the next tick.
+	  if (ev === 'data' && false !== this._readableState.flowing) {
+	    this.resume();
+	  }
+
+	  if (ev === 'readable' && this.readable) {
+	    var state = this._readableState;
+	    if (!state.readableListening) {
+	      state.readableListening = true;
+	      state.emittedReadable = false;
+	      state.needReadable = true;
+	      if (!state.reading) {
+	        var self = this;
+	        process.nextTick(function() {
+	          debug('readable nexttick read 0');
+	          self.read(0);
+	        });
+	      } else if (state.length) {
+	        emitReadable(this, state);
+	      }
+	    }
+	  }
+
+	  return res;
+	};
+	Readable.prototype.addListener = Readable.prototype.on;
+
+	// pause() and resume() are remnants of the legacy readable stream API
+	// If the user uses them, then switch into old mode.
+	Readable.prototype.resume = function() {
+	  var state = this._readableState;
+	  if (!state.flowing) {
+	    debug('resume');
+	    state.flowing = true;
+	    if (!state.reading) {
+	      debug('resume read 0');
+	      this.read(0);
+	    }
+	    resume(this, state);
+	  }
+	  return this;
+	};
+
+	function resume(stream, state) {
+	  if (!state.resumeScheduled) {
+	    state.resumeScheduled = true;
+	    process.nextTick(function() {
+	      resume_(stream, state);
+	    });
+	  }
+	}
+
+	function resume_(stream, state) {
+	  state.resumeScheduled = false;
+	  stream.emit('resume');
+	  flow(stream);
+	  if (state.flowing && !state.reading)
+	    stream.read(0);
+	}
+
+	Readable.prototype.pause = function() {
+	  debug('call pause flowing=%j', this._readableState.flowing);
+	  if (false !== this._readableState.flowing) {
+	    debug('pause');
+	    this._readableState.flowing = false;
+	    this.emit('pause');
+	  }
+	  return this;
+	};
+
+	function flow(stream) {
+	  var state = stream._readableState;
+	  debug('flow', state.flowing);
+	  if (state.flowing) {
+	    do {
+	      var chunk = stream.read();
+	    } while (null !== chunk && state.flowing);
+	  }
+	}
+
+	// wrap an old-style stream as the async data source.
+	// This is *not* part of the readable stream interface.
+	// It is an ugly unfortunate mess of history.
+	Readable.prototype.wrap = function(stream) {
+	  var state = this._readableState;
+	  var paused = false;
+
+	  var self = this;
+	  stream.on('end', function() {
+	    debug('wrapped end');
+	    if (state.decoder && !state.ended) {
+	      var chunk = state.decoder.end();
+	      if (chunk && chunk.length)
+	        self.push(chunk);
+	    }
+
+	    self.push(null);
+	  });
+
+	  stream.on('data', function(chunk) {
+	    debug('wrapped data');
+	    if (state.decoder)
+	      chunk = state.decoder.write(chunk);
+	    if (!chunk || !state.objectMode && !chunk.length)
+	      return;
+
+	    var ret = self.push(chunk);
+	    if (!ret) {
+	      paused = true;
+	      stream.pause();
+	    }
+	  });
+
+	  // proxy all the other methods.
+	  // important when wrapping filters and duplexes.
+	  for (var i in stream) {
+	    if (util.isFunction(stream[i]) && util.isUndefined(this[i])) {
+	      this[i] = function(method) { return function() {
+	        return stream[method].apply(stream, arguments);
+	      }}(i);
+	    }
+	  }
+
+	  // proxy certain important events.
+	  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+	  forEach(events, function(ev) {
+	    stream.on(ev, self.emit.bind(self, ev));
+	  });
+
+	  // when we try to consume some more bytes, simply unpause the
+	  // underlying stream.
+	  self._read = function(n) {
+	    debug('wrapped _read', n);
+	    if (paused) {
+	      paused = false;
+	      stream.resume();
+	    }
+	  };
+
+	  return self;
+	};
+
+
+
+	// exposed for testing purposes only.
+	Readable._fromList = fromList;
+
+	// Pluck off n bytes from an array of buffers.
+	// Length is the combined lengths of all the buffers in the list.
+	function fromList(n, state) {
+	  var list = state.buffer;
+	  var length = state.length;
+	  var stringMode = !!state.decoder;
+	  var objectMode = !!state.objectMode;
+	  var ret;
+
+	  // nothing in the list, definitely empty.
+	  if (list.length === 0)
+	    return null;
+
+	  if (length === 0)
+	    ret = null;
+	  else if (objectMode)
+	    ret = list.shift();
+	  else if (!n || n >= length) {
+	    // read it all, truncate the array.
+	    if (stringMode)
+	      ret = list.join('');
+	    else
+	      ret = Buffer.concat(list, length);
+	    list.length = 0;
+	  } else {
+	    // read just some of it.
+	    if (n < list[0].length) {
+	      // just take a part of the first list item.
+	      // slice is the same for buffers and strings.
+	      var buf = list[0];
+	      ret = buf.slice(0, n);
+	      list[0] = buf.slice(n);
+	    } else if (n === list[0].length) {
+	      // first list is a perfect match
+	      ret = list.shift();
+	    } else {
+	      // complex case.
+	      // we have enough to cover it, but it spans past the first buffer.
+	      if (stringMode)
+	        ret = '';
+	      else
+	        ret = new Buffer(n);
+
+	      var c = 0;
+	      for (var i = 0, l = list.length; i < l && c < n; i++) {
+	        var buf = list[0];
+	        var cpy = Math.min(n - c, buf.length);
+
+	        if (stringMode)
+	          ret += buf.slice(0, cpy);
+	        else
+	          buf.copy(ret, c, 0, cpy);
+
+	        if (cpy < buf.length)
+	          list[0] = buf.slice(cpy);
+	        else
+	          list.shift();
+
+	        c += cpy;
+	      }
+	    }
+	  }
+
+	  return ret;
+	}
+
+	function endReadable(stream) {
+	  var state = stream._readableState;
+
+	  // If we get here before consuming all the bytes, then that is a
+	  // bug in node.  Should never happen.
+	  if (state.length > 0)
+	    throw new Error('endReadable called on non-empty stream');
+
+	  if (!state.endEmitted) {
+	    state.ended = true;
+	    process.nextTick(function() {
+	      // Check that we didn't get one last unshift.
+	      if (!state.endEmitted && state.length === 0) {
+	        state.endEmitted = true;
+	        stream.readable = false;
+	        stream.emit('end');
+	      }
+	    });
+	  }
+	}
+
+	function forEach (xs, f) {
+	  for (var i = 0, l = xs.length; i < l; i++) {
+	    f(xs[i], i);
+	  }
+	}
+
+	function indexOf (xs, x) {
+	  for (var i = 0, l = xs.length; i < l; i++) {
+	    if (xs[i] === x) return i;
+	  }
+	  return -1;
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 27 */
+/***/ function(module, exports) {
+
+	module.exports = Array.isArray || function (arr) {
+	  return Object.prototype.toString.call(arr) == '[object Array]';
+	};
+
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(Buffer, global) {/*!
+	 * The buffer module from node.js, for the browser.
+	 *
+	 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+	 * @license  MIT
+	 */
+	/* eslint-disable no-proto */
+
+	'use strict'
+
+	var base64 = __webpack_require__(29)
+	var ieee754 = __webpack_require__(30)
+	var isArray = __webpack_require__(31)
+
+	exports.Buffer = Buffer
+	exports.SlowBuffer = SlowBuffer
+	exports.INSPECT_MAX_BYTES = 50
+	Buffer.poolSize = 8192 // not used by this implementation
+
+	var rootParent = {}
+
+	/**
+	 * If `Buffer.TYPED_ARRAY_SUPPORT`:
+	 *   === true    Use Uint8Array implementation (fastest)
+	 *   === false   Use Object implementation (most compatible, even IE6)
+	 *
+	 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+	 * Opera 11.6+, iOS 4.2+.
+	 *
+	 * Due to various browser bugs, sometimes the Object implementation will be used even
+	 * when the browser supports typed arrays.
+	 *
+	 * Note:
+	 *
+	 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+	 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+	 *
+	 *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
+	 *     on objects.
+	 *
+	 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+	 *
+	 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+	 *     incorrect length in some situations.
+
+	 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+	 * get the Object implementation, which is slower but behaves correctly.
+	 */
+	Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+	  ? global.TYPED_ARRAY_SUPPORT
+	  : typedArraySupport()
+
+	function typedArraySupport () {
+	  function Bar () {}
+	  try {
+	    var arr = new Uint8Array(1)
+	    arr.foo = function () { return 42 }
+	    arr.constructor = Bar
+	    return arr.foo() === 42 && // typed array instances can be augmented
+	        arr.constructor === Bar && // constructor can be set
+	        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+	        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+	  } catch (e) {
+	    return false
+	  }
+	}
+
+	function kMaxLength () {
+	  return Buffer.TYPED_ARRAY_SUPPORT
+	    ? 0x7fffffff
+	    : 0x3fffffff
+	}
+
+	/**
+	 * Class: Buffer
+	 * =============
+	 *
+	 * The Buffer constructor returns instances of `Uint8Array` that are augmented
+	 * with function properties for all the node `Buffer` API functions. We use
+	 * `Uint8Array` so that square bracket notation works as expected -- it returns
+	 * a single octet.
+	 *
+	 * By augmenting the instances, we can avoid modifying the `Uint8Array`
+	 * prototype.
+	 */
+	function Buffer (arg) {
+	  if (!(this instanceof Buffer)) {
+	    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
+	    if (arguments.length > 1) return new Buffer(arg, arguments[1])
+	    return new Buffer(arg)
+	  }
+
+	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+	    this.length = 0
+	    this.parent = undefined
+	  }
+
+	  // Common case.
+	  if (typeof arg === 'number') {
+	    return fromNumber(this, arg)
+	  }
+
+	  // Slightly less common case.
+	  if (typeof arg === 'string') {
+	    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
+	  }
+
+	  // Unusual.
+	  return fromObject(this, arg)
+	}
+
+	function fromNumber (that, length) {
+	  that = allocate(that, length < 0 ? 0 : checked(length) | 0)
+	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+	    for (var i = 0; i < length; i++) {
+	      that[i] = 0
+	    }
+	  }
+	  return that
+	}
+
+	function fromString (that, string, encoding) {
+	  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
+
+	  // Assumption: byteLength() return value is always < kMaxLength.
+	  var length = byteLength(string, encoding) | 0
+	  that = allocate(that, length)
+
+	  that.write(string, encoding)
+	  return that
+	}
+
+	function fromObject (that, object) {
+	  if (Buffer.isBuffer(object)) return fromBuffer(that, object)
+
+	  if (isArray(object)) return fromArray(that, object)
+
+	  if (object == null) {
+	    throw new TypeError('must start with number, buffer, array or string')
+	  }
+
+	  if (typeof ArrayBuffer !== 'undefined') {
+	    if (object.buffer instanceof ArrayBuffer) {
+	      return fromTypedArray(that, object)
+	    }
+	    if (object instanceof ArrayBuffer) {
+	      return fromArrayBuffer(that, object)
+	    }
+	  }
+
+	  if (object.length) return fromArrayLike(that, object)
+
+	  return fromJsonObject(that, object)
+	}
+
+	function fromBuffer (that, buffer) {
+	  var length = checked(buffer.length) | 0
+	  that = allocate(that, length)
+	  buffer.copy(that, 0, 0, length)
+	  return that
+	}
+
+	function fromArray (that, array) {
+	  var length = checked(array.length) | 0
+	  that = allocate(that, length)
+	  for (var i = 0; i < length; i += 1) {
+	    that[i] = array[i] & 255
+	  }
+	  return that
+	}
+
+	// Duplicate of fromArray() to keep fromArray() monomorphic.
+	function fromTypedArray (that, array) {
+	  var length = checked(array.length) | 0
+	  that = allocate(that, length)
+	  // Truncating the elements is probably not what people expect from typed
+	  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
+	  // of the old Buffer constructor.
+	  for (var i = 0; i < length; i += 1) {
+	    that[i] = array[i] & 255
+	  }
+	  return that
+	}
+
+	function fromArrayBuffer (that, array) {
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    // Return an augmented `Uint8Array` instance, for best performance
+	    array.byteLength
+	    that = Buffer._augment(new Uint8Array(array))
+	  } else {
+	    // Fallback: Return an object instance of the Buffer class
+	    that = fromTypedArray(that, new Uint8Array(array))
+	  }
+	  return that
+	}
+
+	function fromArrayLike (that, array) {
+	  var length = checked(array.length) | 0
+	  that = allocate(that, length)
+	  for (var i = 0; i < length; i += 1) {
+	    that[i] = array[i] & 255
+	  }
+	  return that
+	}
+
+	// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
+	// Returns a zero-length buffer for inputs that don't conform to the spec.
+	function fromJsonObject (that, object) {
+	  var array
+	  var length = 0
+
+	  if (object.type === 'Buffer' && isArray(object.data)) {
+	    array = object.data
+	    length = checked(array.length) | 0
+	  }
+	  that = allocate(that, length)
+
+	  for (var i = 0; i < length; i += 1) {
+	    that[i] = array[i] & 255
+	  }
+	  return that
+	}
+
+	if (Buffer.TYPED_ARRAY_SUPPORT) {
+	  Buffer.prototype.__proto__ = Uint8Array.prototype
+	  Buffer.__proto__ = Uint8Array
+	} else {
+	  // pre-set for values that may exist in the future
+	  Buffer.prototype.length = undefined
+	  Buffer.prototype.parent = undefined
+	}
+
+	function allocate (that, length) {
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    // Return an augmented `Uint8Array` instance, for best performance
+	    that = Buffer._augment(new Uint8Array(length))
+	    that.__proto__ = Buffer.prototype
+	  } else {
+	    // Fallback: Return an object instance of the Buffer class
+	    that.length = length
+	    that._isBuffer = true
+	  }
+
+	  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
+	  if (fromPool) that.parent = rootParent
+
+	  return that
+	}
+
+	function checked (length) {
+	  // Note: cannot use `length < kMaxLength` here because that fails when
+	  // length is NaN (which is otherwise coerced to zero.)
+	  if (length >= kMaxLength()) {
+	    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+	                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
+	  }
+	  return length | 0
+	}
+
+	function SlowBuffer (subject, encoding) {
+	  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
+
+	  var buf = new Buffer(subject, encoding)
+	  delete buf.parent
+	  return buf
+	}
+
+	Buffer.isBuffer = function isBuffer (b) {
+	  return !!(b != null && b._isBuffer)
+	}
+
+	Buffer.compare = function compare (a, b) {
+	  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+	    throw new TypeError('Arguments must be Buffers')
+	  }
+
+	  if (a === b) return 0
+
+	  var x = a.length
+	  var y = b.length
+
+	  var i = 0
+	  var len = Math.min(x, y)
+	  while (i < len) {
+	    if (a[i] !== b[i]) break
+
+	    ++i
+	  }
+
+	  if (i !== len) {
+	    x = a[i]
+	    y = b[i]
+	  }
+
+	  if (x < y) return -1
+	  if (y < x) return 1
+	  return 0
+	}
+
+	Buffer.isEncoding = function isEncoding (encoding) {
+	  switch (String(encoding).toLowerCase()) {
+	    case 'hex':
+	    case 'utf8':
+	    case 'utf-8':
+	    case 'ascii':
+	    case 'binary':
+	    case 'base64':
+	    case 'raw':
+	    case 'ucs2':
+	    case 'ucs-2':
+	    case 'utf16le':
+	    case 'utf-16le':
+	      return true
+	    default:
+	      return false
+	  }
+	}
+
+	Buffer.concat = function concat (list, length) {
+	  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
+
+	  if (list.length === 0) {
+	    return new Buffer(0)
+	  }
+
+	  var i
+	  if (length === undefined) {
+	    length = 0
+	    for (i = 0; i < list.length; i++) {
+	      length += list[i].length
+	    }
+	  }
+
+	  var buf = new Buffer(length)
+	  var pos = 0
+	  for (i = 0; i < list.length; i++) {
+	    var item = list[i]
+	    item.copy(buf, pos)
+	    pos += item.length
+	  }
+	  return buf
+	}
+
+	function byteLength (string, encoding) {
+	  if (typeof string !== 'string') string = '' + string
+
+	  var len = string.length
+	  if (len === 0) return 0
+
+	  // Use a for loop to avoid recursion
+	  var loweredCase = false
+	  for (;;) {
+	    switch (encoding) {
+	      case 'ascii':
+	      case 'binary':
+	      // Deprecated
+	      case 'raw':
+	      case 'raws':
+	        return len
+	      case 'utf8':
+	      case 'utf-8':
+	        return utf8ToBytes(string).length
+	      case 'ucs2':
+	      case 'ucs-2':
+	      case 'utf16le':
+	      case 'utf-16le':
+	        return len * 2
+	      case 'hex':
+	        return len >>> 1
+	      case 'base64':
+	        return base64ToBytes(string).length
+	      default:
+	        if (loweredCase) return utf8ToBytes(string).length // assume utf8
+	        encoding = ('' + encoding).toLowerCase()
+	        loweredCase = true
+	    }
+	  }
+	}
+	Buffer.byteLength = byteLength
+
+	function slowToString (encoding, start, end) {
+	  var loweredCase = false
+
+	  start = start | 0
+	  end = end === undefined || end === Infinity ? this.length : end | 0
+
+	  if (!encoding) encoding = 'utf8'
+	  if (start < 0) start = 0
+	  if (end > this.length) end = this.length
+	  if (end <= start) return ''
+
+	  while (true) {
+	    switch (encoding) {
+	      case 'hex':
+	        return hexSlice(this, start, end)
+
+	      case 'utf8':
+	      case 'utf-8':
+	        return utf8Slice(this, start, end)
+
+	      case 'ascii':
+	        return asciiSlice(this, start, end)
+
+	      case 'binary':
+	        return binarySlice(this, start, end)
+
+	      case 'base64':
+	        return base64Slice(this, start, end)
+
+	      case 'ucs2':
+	      case 'ucs-2':
+	      case 'utf16le':
+	      case 'utf-16le':
+	        return utf16leSlice(this, start, end)
+
+	      default:
+	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+	        encoding = (encoding + '').toLowerCase()
+	        loweredCase = true
+	    }
+	  }
+	}
+
+	Buffer.prototype.toString = function toString () {
+	  var length = this.length | 0
+	  if (length === 0) return ''
+	  if (arguments.length === 0) return utf8Slice(this, 0, length)
+	  return slowToString.apply(this, arguments)
+	}
+
+	Buffer.prototype.equals = function equals (b) {
+	  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+	  if (this === b) return true
+	  return Buffer.compare(this, b) === 0
+	}
+
+	Buffer.prototype.inspect = function inspect () {
+	  var str = ''
+	  var max = exports.INSPECT_MAX_BYTES
+	  if (this.length > 0) {
+	    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+	    if (this.length > max) str += ' ... '
+	  }
+	  return '<Buffer ' + str + '>'
+	}
+
+	Buffer.prototype.compare = function compare (b) {
+	  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+	  if (this === b) return 0
+	  return Buffer.compare(this, b)
+	}
+
+	Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
+	  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
+	  else if (byteOffset < -0x80000000) byteOffset = -0x80000000
+	  byteOffset >>= 0
+
+	  if (this.length === 0) return -1
+	  if (byteOffset >= this.length) return -1
+
+	  // Negative offsets start from the end of the buffer
+	  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
+
+	  if (typeof val === 'string') {
+	    if (val.length === 0) return -1 // special case: looking for empty string always fails
+	    return String.prototype.indexOf.call(this, val, byteOffset)
+	  }
+	  if (Buffer.isBuffer(val)) {
+	    return arrayIndexOf(this, val, byteOffset)
+	  }
+	  if (typeof val === 'number') {
+	    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
+	      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
+	    }
+	    return arrayIndexOf(this, [ val ], byteOffset)
+	  }
+
+	  function arrayIndexOf (arr, val, byteOffset) {
+	    var foundIndex = -1
+	    for (var i = 0; byteOffset + i < arr.length; i++) {
+	      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
+	        if (foundIndex === -1) foundIndex = i
+	        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
+	      } else {
+	        foundIndex = -1
+	      }
+	    }
+	    return -1
+	  }
+
+	  throw new TypeError('val must be string, number or Buffer')
+	}
+
+	// `get` is deprecated
+	Buffer.prototype.get = function get (offset) {
+	  console.log('.get() is deprecated. Access using array indexes instead.')
+	  return this.readUInt8(offset)
+	}
+
+	// `set` is deprecated
+	Buffer.prototype.set = function set (v, offset) {
+	  console.log('.set() is deprecated. Access using array indexes instead.')
+	  return this.writeUInt8(v, offset)
+	}
+
+	function hexWrite (buf, string, offset, length) {
+	  offset = Number(offset) || 0
+	  var remaining = buf.length - offset
+	  if (!length) {
+	    length = remaining
+	  } else {
+	    length = Number(length)
+	    if (length > remaining) {
+	      length = remaining
+	    }
+	  }
+
+	  // must be an even number of digits
+	  var strLen = string.length
+	  if (strLen % 2 !== 0) throw new Error('Invalid hex string')
+
+	  if (length > strLen / 2) {
+	    length = strLen / 2
+	  }
+	  for (var i = 0; i < length; i++) {
+	    var parsed = parseInt(string.substr(i * 2, 2), 16)
+	    if (isNaN(parsed)) throw new Error('Invalid hex string')
+	    buf[offset + i] = parsed
+	  }
+	  return i
+	}
+
+	function utf8Write (buf, string, offset, length) {
+	  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+	}
+
+	function asciiWrite (buf, string, offset, length) {
+	  return blitBuffer(asciiToBytes(string), buf, offset, length)
+	}
+
+	function binaryWrite (buf, string, offset, length) {
+	  return asciiWrite(buf, string, offset, length)
+	}
+
+	function base64Write (buf, string, offset, length) {
+	  return blitBuffer(base64ToBytes(string), buf, offset, length)
+	}
+
+	function ucs2Write (buf, string, offset, length) {
+	  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+	}
+
+	Buffer.prototype.write = function write (string, offset, length, encoding) {
+	  // Buffer#write(string)
+	  if (offset === undefined) {
+	    encoding = 'utf8'
+	    length = this.length
+	    offset = 0
+	  // Buffer#write(string, encoding)
+	  } else if (length === undefined && typeof offset === 'string') {
+	    encoding = offset
+	    length = this.length
+	    offset = 0
+	  // Buffer#write(string, offset[, length][, encoding])
+	  } else if (isFinite(offset)) {
+	    offset = offset | 0
+	    if (isFinite(length)) {
+	      length = length | 0
+	      if (encoding === undefined) encoding = 'utf8'
+	    } else {
+	      encoding = length
+	      length = undefined
+	    }
+	  // legacy write(string, encoding, offset, length) - remove in v0.13
+	  } else {
+	    var swap = encoding
+	    encoding = offset
+	    offset = length | 0
+	    length = swap
+	  }
+
+	  var remaining = this.length - offset
+	  if (length === undefined || length > remaining) length = remaining
+
+	  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+	    throw new RangeError('attempt to write outside buffer bounds')
+	  }
+
+	  if (!encoding) encoding = 'utf8'
+
+	  var loweredCase = false
+	  for (;;) {
+	    switch (encoding) {
+	      case 'hex':
+	        return hexWrite(this, string, offset, length)
+
+	      case 'utf8':
+	      case 'utf-8':
+	        return utf8Write(this, string, offset, length)
+
+	      case 'ascii':
+	        return asciiWrite(this, string, offset, length)
+
+	      case 'binary':
+	        return binaryWrite(this, string, offset, length)
+
+	      case 'base64':
+	        // Warning: maxLength not taken into account in base64Write
+	        return base64Write(this, string, offset, length)
+
+	      case 'ucs2':
+	      case 'ucs-2':
+	      case 'utf16le':
+	      case 'utf-16le':
+	        return ucs2Write(this, string, offset, length)
+
+	      default:
+	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+	        encoding = ('' + encoding).toLowerCase()
+	        loweredCase = true
+	    }
+	  }
+	}
+
+	Buffer.prototype.toJSON = function toJSON () {
+	  return {
+	    type: 'Buffer',
+	    data: Array.prototype.slice.call(this._arr || this, 0)
+	  }
+	}
+
+	function base64Slice (buf, start, end) {
+	  if (start === 0 && end === buf.length) {
+	    return base64.fromByteArray(buf)
+	  } else {
+	    return base64.fromByteArray(buf.slice(start, end))
+	  }
+	}
+
+	function utf8Slice (buf, start, end) {
+	  end = Math.min(buf.length, end)
+	  var res = []
+
+	  var i = start
+	  while (i < end) {
+	    var firstByte = buf[i]
+	    var codePoint = null
+	    var bytesPerSequence = (firstByte > 0xEF) ? 4
+	      : (firstByte > 0xDF) ? 3
+	      : (firstByte > 0xBF) ? 2
+	      : 1
+
+	    if (i + bytesPerSequence <= end) {
+	      var secondByte, thirdByte, fourthByte, tempCodePoint
+
+	      switch (bytesPerSequence) {
+	        case 1:
+	          if (firstByte < 0x80) {
+	            codePoint = firstByte
+	          }
+	          break
+	        case 2:
+	          secondByte = buf[i + 1]
+	          if ((secondByte & 0xC0) === 0x80) {
+	            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+	            if (tempCodePoint > 0x7F) {
+	              codePoint = tempCodePoint
+	            }
+	          }
+	          break
+	        case 3:
+	          secondByte = buf[i + 1]
+	          thirdByte = buf[i + 2]
+	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+	            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+	            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+	              codePoint = tempCodePoint
+	            }
+	          }
+	          break
+	        case 4:
+	          secondByte = buf[i + 1]
+	          thirdByte = buf[i + 2]
+	          fourthByte = buf[i + 3]
+	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+	            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+	            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+	              codePoint = tempCodePoint
+	            }
+	          }
+	      }
+	    }
+
+	    if (codePoint === null) {
+	      // we did not generate a valid codePoint so insert a
+	      // replacement char (U+FFFD) and advance only 1 byte
+	      codePoint = 0xFFFD
+	      bytesPerSequence = 1
+	    } else if (codePoint > 0xFFFF) {
+	      // encode to utf16 (surrogate pair dance)
+	      codePoint -= 0x10000
+	      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+	      codePoint = 0xDC00 | codePoint & 0x3FF
+	    }
+
+	    res.push(codePoint)
+	    i += bytesPerSequence
+	  }
+
+	  return decodeCodePointsArray(res)
+	}
+
+	// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+	// the lowest limit is Chrome, with 0x10000 args.
+	// We go 1 magnitude less, for safety
+	var MAX_ARGUMENTS_LENGTH = 0x1000
+
+	function decodeCodePointsArray (codePoints) {
+	  var len = codePoints.length
+	  if (len <= MAX_ARGUMENTS_LENGTH) {
+	    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+	  }
+
+	  // Decode in chunks to avoid "call stack size exceeded".
+	  var res = ''
+	  var i = 0
+	  while (i < len) {
+	    res += String.fromCharCode.apply(
+	      String,
+	      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+	    )
+	  }
+	  return res
+	}
+
+	function asciiSlice (buf, start, end) {
+	  var ret = ''
+	  end = Math.min(buf.length, end)
+
+	  for (var i = start; i < end; i++) {
+	    ret += String.fromCharCode(buf[i] & 0x7F)
+	  }
+	  return ret
+	}
+
+	function binarySlice (buf, start, end) {
+	  var ret = ''
+	  end = Math.min(buf.length, end)
+
+	  for (var i = start; i < end; i++) {
+	    ret += String.fromCharCode(buf[i])
+	  }
+	  return ret
+	}
+
+	function hexSlice (buf, start, end) {
+	  var len = buf.length
+
+	  if (!start || start < 0) start = 0
+	  if (!end || end < 0 || end > len) end = len
+
+	  var out = ''
+	  for (var i = start; i < end; i++) {
+	    out += toHex(buf[i])
+	  }
+	  return out
+	}
+
+	function utf16leSlice (buf, start, end) {
+	  var bytes = buf.slice(start, end)
+	  var res = ''
+	  for (var i = 0; i < bytes.length; i += 2) {
+	    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+	  }
+	  return res
+	}
+
+	Buffer.prototype.slice = function slice (start, end) {
+	  var len = this.length
+	  start = ~~start
+	  end = end === undefined ? len : ~~end
+
+	  if (start < 0) {
+	    start += len
+	    if (start < 0) start = 0
+	  } else if (start > len) {
+	    start = len
+	  }
+
+	  if (end < 0) {
+	    end += len
+	    if (end < 0) end = 0
+	  } else if (end > len) {
+	    end = len
+	  }
+
+	  if (end < start) end = start
+
+	  var newBuf
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    newBuf = Buffer._augment(this.subarray(start, end))
+	  } else {
+	    var sliceLen = end - start
+	    newBuf = new Buffer(sliceLen, undefined)
+	    for (var i = 0; i < sliceLen; i++) {
+	      newBuf[i] = this[i + start]
+	    }
+	  }
+
+	  if (newBuf.length) newBuf.parent = this.parent || this
+
+	  return newBuf
+	}
+
+	/*
+	 * Need to make sure that buffer isn't trying to write out of bounds.
+	 */
+	function checkOffset (offset, ext, length) {
+	  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+	  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+	}
+
+	Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+	  var val = this[offset]
+	  var mul = 1
+	  var i = 0
+	  while (++i < byteLength && (mul *= 0x100)) {
+	    val += this[offset + i] * mul
+	  }
+
+	  return val
+	}
+
+	Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) {
+	    checkOffset(offset, byteLength, this.length)
+	  }
+
+	  var val = this[offset + --byteLength]
+	  var mul = 1
+	  while (byteLength > 0 && (mul *= 0x100)) {
+	    val += this[offset + --byteLength] * mul
+	  }
+
+	  return val
+	}
+
+	Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 1, this.length)
+	  return this[offset]
+	}
+
+	Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 2, this.length)
+	  return this[offset] | (this[offset + 1] << 8)
+	}
+
+	Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 2, this.length)
+	  return (this[offset] << 8) | this[offset + 1]
+	}
+
+	Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+
+	  return ((this[offset]) |
+	      (this[offset + 1] << 8) |
+	      (this[offset + 2] << 16)) +
+	      (this[offset + 3] * 0x1000000)
+	}
+
+	Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+
+	  return (this[offset] * 0x1000000) +
+	    ((this[offset + 1] << 16) |
+	    (this[offset + 2] << 8) |
+	    this[offset + 3])
+	}
+
+	Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+	  var val = this[offset]
+	  var mul = 1
+	  var i = 0
+	  while (++i < byteLength && (mul *= 0x100)) {
+	    val += this[offset + i] * mul
+	  }
+	  mul *= 0x80
+
+	  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+	  return val
+	}
+
+	Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+	  var i = byteLength
+	  var mul = 1
+	  var val = this[offset + --i]
+	  while (i > 0 && (mul *= 0x100)) {
+	    val += this[offset + --i] * mul
+	  }
+	  mul *= 0x80
+
+	  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+	  return val
+	}
+
+	Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 1, this.length)
+	  if (!(this[offset] & 0x80)) return (this[offset])
+	  return ((0xff - this[offset] + 1) * -1)
+	}
+
+	Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 2, this.length)
+	  var val = this[offset] | (this[offset + 1] << 8)
+	  return (val & 0x8000) ? val | 0xFFFF0000 : val
+	}
+
+	Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 2, this.length)
+	  var val = this[offset + 1] | (this[offset] << 8)
+	  return (val & 0x8000) ? val | 0xFFFF0000 : val
+	}
+
+	Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+
+	  return (this[offset]) |
+	    (this[offset + 1] << 8) |
+	    (this[offset + 2] << 16) |
+	    (this[offset + 3] << 24)
+	}
+
+	Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+
+	  return (this[offset] << 24) |
+	    (this[offset + 1] << 16) |
+	    (this[offset + 2] << 8) |
+	    (this[offset + 3])
+	}
+
+	Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+	  return ieee754.read(this, offset, true, 23, 4)
+	}
+
+	Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 4, this.length)
+	  return ieee754.read(this, offset, false, 23, 4)
+	}
+
+	Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 8, this.length)
+	  return ieee754.read(this, offset, true, 52, 8)
+	}
+
+	Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+	  if (!noAssert) checkOffset(offset, 8, this.length)
+	  return ieee754.read(this, offset, false, 52, 8)
+	}
+
+	function checkInt (buf, value, offset, ext, max, min) {
+	  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
+	  if (value > max || value < min) throw new RangeError('value is out of bounds')
+	  if (offset + ext > buf.length) throw new RangeError('index out of range')
+	}
+
+	Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
+
+	  var mul = 1
+	  var i = 0
+	  this[offset] = value & 0xFF
+	  while (++i < byteLength && (mul *= 0x100)) {
+	    this[offset + i] = (value / mul) & 0xFF
+	  }
+
+	  return offset + byteLength
+	}
+
+	Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  byteLength = byteLength | 0
+	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
+
+	  var i = byteLength - 1
+	  var mul = 1
+	  this[offset + i] = value & 0xFF
+	  while (--i >= 0 && (mul *= 0x100)) {
+	    this[offset + i] = (value / mul) & 0xFF
+	  }
+
+	  return offset + byteLength
+	}
+
+	Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+	  this[offset] = (value & 0xff)
+	  return offset + 1
+	}
+
+	function objectWriteUInt16 (buf, value, offset, littleEndian) {
+	  if (value < 0) value = 0xffff + value + 1
+	  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
+	    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+	      (littleEndian ? i : 1 - i) * 8
+	  }
+	}
+
+	Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value & 0xff)
+	    this[offset + 1] = (value >>> 8)
+	  } else {
+	    objectWriteUInt16(this, value, offset, true)
+	  }
+	  return offset + 2
+	}
+
+	Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value >>> 8)
+	    this[offset + 1] = (value & 0xff)
+	  } else {
+	    objectWriteUInt16(this, value, offset, false)
+	  }
+	  return offset + 2
+	}
+
+	function objectWriteUInt32 (buf, value, offset, littleEndian) {
+	  if (value < 0) value = 0xffffffff + value + 1
+	  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
+	    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+	  }
+	}
+
+	Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset + 3] = (value >>> 24)
+	    this[offset + 2] = (value >>> 16)
+	    this[offset + 1] = (value >>> 8)
+	    this[offset] = (value & 0xff)
+	  } else {
+	    objectWriteUInt32(this, value, offset, true)
+	  }
+	  return offset + 4
+	}
+
+	Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value >>> 24)
+	    this[offset + 1] = (value >>> 16)
+	    this[offset + 2] = (value >>> 8)
+	    this[offset + 3] = (value & 0xff)
+	  } else {
+	    objectWriteUInt32(this, value, offset, false)
+	  }
+	  return offset + 4
+	}
+
+	Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) {
+	    var limit = Math.pow(2, 8 * byteLength - 1)
+
+	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+	  }
+
+	  var i = 0
+	  var mul = 1
+	  var sub = value < 0 ? 1 : 0
+	  this[offset] = value & 0xFF
+	  while (++i < byteLength && (mul *= 0x100)) {
+	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+	  }
+
+	  return offset + byteLength
+	}
+
+	Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) {
+	    var limit = Math.pow(2, 8 * byteLength - 1)
+
+	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+	  }
+
+	  var i = byteLength - 1
+	  var mul = 1
+	  var sub = value < 0 ? 1 : 0
+	  this[offset + i] = value & 0xFF
+	  while (--i >= 0 && (mul *= 0x100)) {
+	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+	  }
+
+	  return offset + byteLength
+	}
+
+	Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+	  if (value < 0) value = 0xff + value + 1
+	  this[offset] = (value & 0xff)
+	  return offset + 1
+	}
+
+	Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value & 0xff)
+	    this[offset + 1] = (value >>> 8)
+	  } else {
+	    objectWriteUInt16(this, value, offset, true)
+	  }
+	  return offset + 2
+	}
+
+	Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value >>> 8)
+	    this[offset + 1] = (value & 0xff)
+	  } else {
+	    objectWriteUInt16(this, value, offset, false)
+	  }
+	  return offset + 2
+	}
+
+	Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value & 0xff)
+	    this[offset + 1] = (value >>> 8)
+	    this[offset + 2] = (value >>> 16)
+	    this[offset + 3] = (value >>> 24)
+	  } else {
+	    objectWriteUInt32(this, value, offset, true)
+	  }
+	  return offset + 4
+	}
+
+	Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+	  value = +value
+	  offset = offset | 0
+	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+	  if (value < 0) value = 0xffffffff + value + 1
+	  if (Buffer.TYPED_ARRAY_SUPPORT) {
+	    this[offset] = (value >>> 24)
+	    this[offset + 1] = (value >>> 16)
+	    this[offset + 2] = (value >>> 8)
+	    this[offset + 3] = (value & 0xff)
+	  } else {
+	    objectWriteUInt32(this, value, offset, false)
+	  }
+	  return offset + 4
+	}
+
+	function checkIEEE754 (buf, value, offset, ext, max, min) {
+	  if (value > max || value < min) throw new RangeError('value is out of bounds')
+	  if (offset + ext > buf.length) throw new RangeError('index out of range')
+	  if (offset < 0) throw new RangeError('index out of range')
+	}
+
+	function writeFloat (buf, value, offset, littleEndian, noAssert) {
+	  if (!noAssert) {
+	    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+	  }
+	  ieee754.write(buf, value, offset, littleEndian, 23, 4)
+	  return offset + 4
+	}
+
+	Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+	  return writeFloat(this, value, offset, true, noAssert)
+	}
+
+	Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+	  return writeFloat(this, value, offset, false, noAssert)
+	}
+
+	function writeDouble (buf, value, offset, littleEndian, noAssert) {
+	  if (!noAssert) {
+	    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+	  }
+	  ieee754.write(buf, value, offset, littleEndian, 52, 8)
+	  return offset + 8
+	}
+
+	Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+	  return writeDouble(this, value, offset, true, noAssert)
+	}
+
+	Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+	  return writeDouble(this, value, offset, false, noAssert)
+	}
+
+	// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+	Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+	  if (!start) start = 0
+	  if (!end && end !== 0) end = this.length
+	  if (targetStart >= target.length) targetStart = target.length
+	  if (!targetStart) targetStart = 0
+	  if (end > 0 && end < start) end = start
+
+	  // Copy 0 bytes; we're done
+	  if (end === start) return 0
+	  if (target.length === 0 || this.length === 0) return 0
+
+	  // Fatal error conditions
+	  if (targetStart < 0) {
+	    throw new RangeError('targetStart out of bounds')
+	  }
+	  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+	  if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+	  // Are we oob?
+	  if (end > this.length) end = this.length
+	  if (target.length - targetStart < end - start) {
+	    end = target.length - targetStart + start
+	  }
+
+	  var len = end - start
+	  var i
+
+	  if (this === target && start < targetStart && targetStart < end) {
+	    // descending copy from end
+	    for (i = len - 1; i >= 0; i--) {
+	      target[i + targetStart] = this[i + start]
+	    }
+	  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+	    // ascending copy from start
+	    for (i = 0; i < len; i++) {
+	      target[i + targetStart] = this[i + start]
+	    }
+	  } else {
+	    target._set(this.subarray(start, start + len), targetStart)
+	  }
+
+	  return len
+	}
+
+	// fill(value, start=0, end=buffer.length)
+	Buffer.prototype.fill = function fill (value, start, end) {
+	  if (!value) value = 0
+	  if (!start) start = 0
+	  if (!end) end = this.length
+
+	  if (end < start) throw new RangeError('end < start')
+
+	  // Fill 0 bytes; we're done
+	  if (end === start) return
+	  if (this.length === 0) return
+
+	  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
+	  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
+
+	  var i
+	  if (typeof value === 'number') {
+	    for (i = start; i < end; i++) {
+	      this[i] = value
+	    }
+	  } else {
+	    var bytes = utf8ToBytes(value.toString())
+	    var len = bytes.length
+	    for (i = start; i < end; i++) {
+	      this[i] = bytes[i % len]
+	    }
+	  }
+
+	  return this
+	}
+
+	/**
+	 * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
+	 * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
+	 */
+	Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
+	  if (typeof Uint8Array !== 'undefined') {
+	    if (Buffer.TYPED_ARRAY_SUPPORT) {
+	      return (new Buffer(this)).buffer
+	    } else {
+	      var buf = new Uint8Array(this.length)
+	      for (var i = 0, len = buf.length; i < len; i += 1) {
+	        buf[i] = this[i]
+	      }
+	      return buf.buffer
+	    }
+	  } else {
+	    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
+	  }
+	}
+
+	// HELPER FUNCTIONS
+	// ================
+
+	var BP = Buffer.prototype
+
+	/**
+	 * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
+	 */
+	Buffer._augment = function _augment (arr) {
+	  arr.constructor = Buffer
+	  arr._isBuffer = true
+
+	  // save reference to original Uint8Array set method before overwriting
+	  arr._set = arr.set
+
+	  // deprecated
+	  arr.get = BP.get
+	  arr.set = BP.set
+
+	  arr.write = BP.write
+	  arr.toString = BP.toString
+	  arr.toLocaleString = BP.toString
+	  arr.toJSON = BP.toJSON
+	  arr.equals = BP.equals
+	  arr.compare = BP.compare
+	  arr.indexOf = BP.indexOf
+	  arr.copy = BP.copy
+	  arr.slice = BP.slice
+	  arr.readUIntLE = BP.readUIntLE
+	  arr.readUIntBE = BP.readUIntBE
+	  arr.readUInt8 = BP.readUInt8
+	  arr.readUInt16LE = BP.readUInt16LE
+	  arr.readUInt16BE = BP.readUInt16BE
+	  arr.readUInt32LE = BP.readUInt32LE
+	  arr.readUInt32BE = BP.readUInt32BE
+	  arr.readIntLE = BP.readIntLE
+	  arr.readIntBE = BP.readIntBE
+	  arr.readInt8 = BP.readInt8
+	  arr.readInt16LE = BP.readInt16LE
+	  arr.readInt16BE = BP.readInt16BE
+	  arr.readInt32LE = BP.readInt32LE
+	  arr.readInt32BE = BP.readInt32BE
+	  arr.readFloatLE = BP.readFloatLE
+	  arr.readFloatBE = BP.readFloatBE
+	  arr.readDoubleLE = BP.readDoubleLE
+	  arr.readDoubleBE = BP.readDoubleBE
+	  arr.writeUInt8 = BP.writeUInt8
+	  arr.writeUIntLE = BP.writeUIntLE
+	  arr.writeUIntBE = BP.writeUIntBE
+	  arr.writeUInt16LE = BP.writeUInt16LE
+	  arr.writeUInt16BE = BP.writeUInt16BE
+	  arr.writeUInt32LE = BP.writeUInt32LE
+	  arr.writeUInt32BE = BP.writeUInt32BE
+	  arr.writeIntLE = BP.writeIntLE
+	  arr.writeIntBE = BP.writeIntBE
+	  arr.writeInt8 = BP.writeInt8
+	  arr.writeInt16LE = BP.writeInt16LE
+	  arr.writeInt16BE = BP.writeInt16BE
+	  arr.writeInt32LE = BP.writeInt32LE
+	  arr.writeInt32BE = BP.writeInt32BE
+	  arr.writeFloatLE = BP.writeFloatLE
+	  arr.writeFloatBE = BP.writeFloatBE
+	  arr.writeDoubleLE = BP.writeDoubleLE
+	  arr.writeDoubleBE = BP.writeDoubleBE
+	  arr.fill = BP.fill
+	  arr.inspect = BP.inspect
+	  arr.toArrayBuffer = BP.toArrayBuffer
+
+	  return arr
+	}
+
+	var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+
+	function base64clean (str) {
+	  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+	  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+	  // Node converts strings with length < 2 to ''
+	  if (str.length < 2) return ''
+	  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+	  while (str.length % 4 !== 0) {
+	    str = str + '='
+	  }
+	  return str
+	}
+
+	function stringtrim (str) {
+	  if (str.trim) return str.trim()
+	  return str.replace(/^\s+|\s+$/g, '')
+	}
+
+	function toHex (n) {
+	  if (n < 16) return '0' + n.toString(16)
+	  return n.toString(16)
+	}
+
+	function utf8ToBytes (string, units) {
+	  units = units || Infinity
+	  var codePoint
+	  var length = string.length
+	  var leadSurrogate = null
+	  var bytes = []
+
+	  for (var i = 0; i < length; i++) {
+	    codePoint = string.charCodeAt(i)
+
+	    // is surrogate component
+	    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+	      // last char was a lead
+	      if (!leadSurrogate) {
+	        // no lead yet
+	        if (codePoint > 0xDBFF) {
+	          // unexpected trail
+	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+	          continue
+	        } else if (i + 1 === length) {
+	          // unpaired lead
+	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+	          continue
+	        }
+
+	        // valid lead
+	        leadSurrogate = codePoint
+
+	        continue
+	      }
+
+	      // 2 leads in a row
+	      if (codePoint < 0xDC00) {
+	        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+	        leadSurrogate = codePoint
+	        continue
+	      }
+
+	      // valid surrogate pair
+	      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+	    } else if (leadSurrogate) {
+	      // valid bmp char, but last char was a lead
+	      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+	    }
+
+	    leadSurrogate = null
+
+	    // encode utf8
+	    if (codePoint < 0x80) {
+	      if ((units -= 1) < 0) break
+	      bytes.push(codePoint)
+	    } else if (codePoint < 0x800) {
+	      if ((units -= 2) < 0) break
+	      bytes.push(
+	        codePoint >> 0x6 | 0xC0,
+	        codePoint & 0x3F | 0x80
+	      )
+	    } else if (codePoint < 0x10000) {
+	      if ((units -= 3) < 0) break
+	      bytes.push(
+	        codePoint >> 0xC | 0xE0,
+	        codePoint >> 0x6 & 0x3F | 0x80,
+	        codePoint & 0x3F | 0x80
+	      )
+	    } else if (codePoint < 0x110000) {
+	      if ((units -= 4) < 0) break
+	      bytes.push(
+	        codePoint >> 0x12 | 0xF0,
+	        codePoint >> 0xC & 0x3F | 0x80,
+	        codePoint >> 0x6 & 0x3F | 0x80,
+	        codePoint & 0x3F | 0x80
+	      )
+	    } else {
+	      throw new Error('Invalid code point')
+	    }
+	  }
+
+	  return bytes
+	}
+
+	function asciiToBytes (str) {
+	  var byteArray = []
+	  for (var i = 0; i < str.length; i++) {
+	    // Node's code seems to be doing this and not & 0x7F..
+	    byteArray.push(str.charCodeAt(i) & 0xFF)
+	  }
+	  return byteArray
+	}
+
+	function utf16leToBytes (str, units) {
+	  var c, hi, lo
+	  var byteArray = []
+	  for (var i = 0; i < str.length; i++) {
+	    if ((units -= 2) < 0) break
+
+	    c = str.charCodeAt(i)
+	    hi = c >> 8
+	    lo = c % 256
+	    byteArray.push(lo)
+	    byteArray.push(hi)
+	  }
+
+	  return byteArray
+	}
+
+	function base64ToBytes (str) {
+	  return base64.toByteArray(base64clean(str))
+	}
+
+	function blitBuffer (src, dst, offset, length) {
+	  for (var i = 0; i < length; i++) {
+	    if ((i + offset >= dst.length) || (i >= src.length)) break
+	    dst[i + offset] = src[i]
+	  }
+	  return i
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(28).Buffer, (function() { return this; }())))
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+	;(function (exports) {
+		'use strict';
+
+	  var Arr = (typeof Uint8Array !== 'undefined')
+	    ? Uint8Array
+	    : Array
+
+		var PLUS   = '+'.charCodeAt(0)
+		var SLASH  = '/'.charCodeAt(0)
+		var NUMBER = '0'.charCodeAt(0)
+		var LOWER  = 'a'.charCodeAt(0)
+		var UPPER  = 'A'.charCodeAt(0)
+		var PLUS_URL_SAFE = '-'.charCodeAt(0)
+		var SLASH_URL_SAFE = '_'.charCodeAt(0)
+
+		function decode (elt) {
+			var code = elt.charCodeAt(0)
+			if (code === PLUS ||
+			    code === PLUS_URL_SAFE)
+				return 62 // '+'
+			if (code === SLASH ||
+			    code === SLASH_URL_SAFE)
+				return 63 // '/'
+			if (code < NUMBER)
+				return -1 //no match
+			if (code < NUMBER + 10)
+				return code - NUMBER + 26 + 26
+			if (code < UPPER + 26)
+				return code - UPPER
+			if (code < LOWER + 26)
+				return code - LOWER + 26
+		}
+
+		function b64ToByteArray (b64) {
+			var i, j, l, tmp, placeHolders, arr
+
+			if (b64.length % 4 > 0) {
+				throw new Error('Invalid string. Length must be a multiple of 4')
+			}
+
+			// the number of equal signs (place holders)
+			// if there are two placeholders, than the two characters before it
+			// represent one byte
+			// if there is only one, then the three characters before it represent 2 bytes
+			// this is just a cheap hack to not do indexOf twice
+			var len = b64.length
+			placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+			// base64 is 4/3 + up to two characters of the original data
+			arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+			// if there are placeholders, only get up to the last complete 4 chars
+			l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+			var L = 0
+
+			function push (v) {
+				arr[L++] = v
+			}
+
+			for (i = 0, j = 0; i < l; i += 4, j += 3) {
+				tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+				push((tmp & 0xFF0000) >> 16)
+				push((tmp & 0xFF00) >> 8)
+				push(tmp & 0xFF)
+			}
+
+			if (placeHolders === 2) {
+				tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+				push(tmp & 0xFF)
+			} else if (placeHolders === 1) {
+				tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+				push((tmp >> 8) & 0xFF)
+				push(tmp & 0xFF)
+			}
+
+			return arr
+		}
+
+		function uint8ToBase64 (uint8) {
+			var i,
+				extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+				output = "",
+				temp, length
+
+			function encode (num) {
+				return lookup.charAt(num)
+			}
+
+			function tripletToBase64 (num) {
+				return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+			}
+
+			// go through the array every three bytes, we'll deal with trailing stuff later
+			for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+				temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+				output += tripletToBase64(temp)
+			}
+
+			// pad the end with zeros, but make sure to not forget the extra bytes
+			switch (extraBytes) {
+				case 1:
+					temp = uint8[uint8.length - 1]
+					output += encode(temp >> 2)
+					output += encode((temp << 4) & 0x3F)
+					output += '=='
+					break
+				case 2:
+					temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+					output += encode(temp >> 10)
+					output += encode((temp >> 4) & 0x3F)
+					output += encode((temp << 2) & 0x3F)
+					output += '='
+					break
+			}
+
+			return output
+		}
+
+		exports.toByteArray = b64ToByteArray
+		exports.fromByteArray = uint8ToBase64
+	}( false ? (this.base64js = {}) : exports))
+
+
+/***/ },
+/* 30 */
+/***/ function(module, exports) {
+
+	exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+	  var e, m
+	  var eLen = nBytes * 8 - mLen - 1
+	  var eMax = (1 << eLen) - 1
+	  var eBias = eMax >> 1
+	  var nBits = -7
+	  var i = isLE ? (nBytes - 1) : 0
+	  var d = isLE ? -1 : 1
+	  var s = buffer[offset + i]
+
+	  i += d
+
+	  e = s & ((1 << (-nBits)) - 1)
+	  s >>= (-nBits)
+	  nBits += eLen
+	  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+	  m = e & ((1 << (-nBits)) - 1)
+	  e >>= (-nBits)
+	  nBits += mLen
+	  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+	  if (e === 0) {
+	    e = 1 - eBias
+	  } else if (e === eMax) {
+	    return m ? NaN : ((s ? -1 : 1) * Infinity)
+	  } else {
+	    m = m + Math.pow(2, mLen)
+	    e = e - eBias
+	  }
+	  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+	}
+
+	exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+	  var e, m, c
+	  var eLen = nBytes * 8 - mLen - 1
+	  var eMax = (1 << eLen) - 1
+	  var eBias = eMax >> 1
+	  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+	  var i = isLE ? 0 : (nBytes - 1)
+	  var d = isLE ? 1 : -1
+	  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+	  value = Math.abs(value)
+
+	  if (isNaN(value) || value === Infinity) {
+	    m = isNaN(value) ? 1 : 0
+	    e = eMax
+	  } else {
+	    e = Math.floor(Math.log(value) / Math.LN2)
+	    if (value * (c = Math.pow(2, -e)) < 1) {
+	      e--
+	      c *= 2
+	    }
+	    if (e + eBias >= 1) {
+	      value += rt / c
+	    } else {
+	      value += rt * Math.pow(2, 1 - eBias)
+	    }
+	    if (value * c >= 2) {
+	      e++
+	      c /= 2
+	    }
+
+	    if (e + eBias >= eMax) {
+	      m = 0
+	      e = eMax
+	    } else if (e + eBias >= 1) {
+	      m = (value * c - 1) * Math.pow(2, mLen)
+	      e = e + eBias
+	    } else {
+	      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+	      e = 0
+	    }
+	  }
+
+	  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+	  e = (e << mLen) | m
+	  eLen += mLen
+	  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+	  buffer[offset + i - d] |= s * 128
+	}
+
+
+/***/ },
+/* 31 */
+/***/ function(module, exports) {
+
+	var toString = {}.toString;
+
+	module.exports = Array.isArray || function (arr) {
+	  return toString.call(arr) == '[object Array]';
+	};
+
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(Buffer) {// 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.
+
+	// NOTE: These type checking functions intentionally don't use `instanceof`
+	// because it is fragile and can be easily faked with `Object.create()`.
+
+	function isArray(arg) {
+	  if (Array.isArray) {
+	    return Array.isArray(arg);
+	  }
+	  return objectToString(arg) === '[object Array]';
+	}
+	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 objectToString(re) === '[object RegExp]';
+	}
+	exports.isRegExp = isRegExp;
+
+	function isObject(arg) {
+	  return typeof arg === 'object' && arg !== null;
+	}
+	exports.isObject = isObject;
+
+	function isDate(d) {
+	  return objectToString(d) === '[object Date]';
+	}
+	exports.isDate = isDate;
+
+	function isError(e) {
+	  return (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 = Buffer.isBuffer;
+
+	function objectToString(o) {
+	  return Object.prototype.toString.call(o);
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(28).Buffer))
+
+/***/ },
+/* 33 */
+/***/ function(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
+	  }
+	}
+
+
+/***/ },
+/* 34 */
+/***/ function(module, exports) {
+
+	/* (ignored) */
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {// 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.
+
+	// a duplex stream is just a stream that is both readable and writable.
+	// Since JS doesn't have multiple prototypal inheritance, this class
+	// prototypally inherits from Readable, and then parasitically from
+	// Writable.
+
+	module.exports = Duplex;
+
+	/*<replacement>*/
+	var objectKeys = Object.keys || function (obj) {
+	  var keys = [];
+	  for (var key in obj) keys.push(key);
+	  return keys;
+	}
+	/*</replacement>*/
+
+
+	/*<replacement>*/
+	var util = __webpack_require__(32);
+	util.inherits = __webpack_require__(33);
+	/*</replacement>*/
+
+	var Readable = __webpack_require__(26);
+	var Writable = __webpack_require__(36);
+
+	util.inherits(Duplex, Readable);
+
+	forEach(objectKeys(Writable.prototype), function(method) {
+	  if (!Duplex.prototype[method])
+	    Duplex.prototype[method] = Writable.prototype[method];
+	});
+
+	function Duplex(options) {
+	  if (!(this instanceof Duplex))
+	    return new Duplex(options);
+
+	  Readable.call(this, options);
+	  Writable.call(this, options);
+
+	  if (options && options.readable === false)
+	    this.readable = false;
+
+	  if (options && options.writable === false)
+	    this.writable = false;
+
+	  this.allowHalfOpen = true;
+	  if (options && options.allowHalfOpen === false)
+	    this.allowHalfOpen = false;
+
+	  this.once('end', onend);
+	}
+
+	// the no-half-open enforcer
+	function onend() {
+	  // if we allow half-open state, or if the writable side ended,
+	  // then we're ok.
+	  if (this.allowHalfOpen || this._writableState.ended)
+	    return;
+
+	  // no more data can be written.
+	  // But allow more writes to happen in this tick.
+	  process.nextTick(this.end.bind(this));
+	}
+
+	function forEach (xs, f) {
+	  for (var i = 0, l = xs.length; i < l; i++) {
+	    f(xs[i], i);
+	  }
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {// 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.
+
+	// A bit simpler than readable streams.
+	// Implement an async ._write(chunk, cb), and it'll handle all
+	// the drain event emission and buffering.
+
+	module.exports = Writable;
+
+	/*<replacement>*/
+	var Buffer = __webpack_require__(28).Buffer;
+	/*</replacement>*/
+
+	Writable.WritableState = WritableState;
+
+
+	/*<replacement>*/
+	var util = __webpack_require__(32);
+	util.inherits = __webpack_require__(33);
+	/*</replacement>*/
+
+	var Stream = __webpack_require__(23);
+
+	util.inherits(Writable, Stream);
+
+	function WriteReq(chunk, encoding, cb) {
+	  this.chunk = chunk;
+	  this.encoding = encoding;
+	  this.callback = cb;
+	}
+
+	function WritableState(options, stream) {
+	  var Duplex = __webpack_require__(35);
+
+	  options = options || {};
+
+	  // the point at which write() starts returning false
+	  // Note: 0 is a valid value, means that we always return false if
+	  // the entire buffer is not flushed immediately on write()
+	  var hwm = options.highWaterMark;
+	  var defaultHwm = options.objectMode ? 16 : 16 * 1024;
+	  this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
+
+	  // object stream flag to indicate whether or not this stream
+	  // contains buffers or objects.
+	  this.objectMode = !!options.objectMode;
+
+	  if (stream instanceof Duplex)
+	    this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+	  // cast to ints.
+	  this.highWaterMark = ~~this.highWaterMark;
+
+	  this.needDrain = false;
+	  // at the start of calling end()
+	  this.ending = false;
+	  // when end() has been called, and returned
+	  this.ended = false;
+	  // when 'finish' is emitted
+	  this.finished = false;
+
+	  // should we decode strings into buffers before passing to _write?
+	  // this is here so that some node-core streams can optimize string
+	  // handling at a lower level.
+	  var noDecode = options.decodeStrings === false;
+	  this.decodeStrings = !noDecode;
+
+	  // Crypto is kind of old and crusty.  Historically, its default string
+	  // encoding is 'binary' so we have to make this configurable.
+	  // Everything else in the universe uses 'utf8', though.
+	  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+	  // not an actual buffer we keep track of, but a measurement
+	  // of how much we're waiting to get pushed to some underlying
+	  // socket or file.
+	  this.length = 0;
+
+	  // a flag to see when we're in the middle of a write.
+	  this.writing = false;
+
+	  // when true all writes will be buffered until .uncork() call
+	  this.corked = 0;
+
+	  // a flag to be able to tell if the onwrite cb is called immediately,
+	  // or on a later tick.  We set this to true at first, because any
+	  // actions that shouldn't happen until "later" should generally also
+	  // not happen before the first write call.
+	  this.sync = true;
+
+	  // a flag to know if we're processing previously buffered items, which
+	  // may call the _write() callback in the same tick, so that we don't
+	  // end up in an overlapped onwrite situation.
+	  this.bufferProcessing = false;
+
+	  // the callback that's passed to _write(chunk,cb)
+	  this.onwrite = function(er) {
+	    onwrite(stream, er);
+	  };
+
+	  // the callback that the user supplies to write(chunk,encoding,cb)
+	  this.writecb = null;
+
+	  // the amount that is being written when _write is called.
+	  this.writelen = 0;
+
+	  this.buffer = [];
+
+	  // number of pending user-supplied write callbacks
+	  // this must be 0 before 'finish' can be emitted
+	  this.pendingcb = 0;
+
+	  // emit prefinish if the only thing we're waiting for is _write cbs
+	  // This is relevant for synchronous Transform streams
+	  this.prefinished = false;
+
+	  // True if the error was already emitted and should not be thrown again
+	  this.errorEmitted = false;
+	}
+
+	function Writable(options) {
+	  var Duplex = __webpack_require__(35);
+
+	  // Writable ctor is applied to Duplexes, though they're not
+	  // instanceof Writable, they're instanceof Readable.
+	  if (!(this instanceof Writable) && !(this instanceof Duplex))
+	    return new Writable(options);
+
+	  this._writableState = new WritableState(options, this);
+
+	  // legacy.
+	  this.writable = true;
+
+	  Stream.call(this);
+	}
+
+	// Otherwise people can pipe Writable streams, which is just wrong.
+	Writable.prototype.pipe = function() {
+	  this.emit('error', new Error('Cannot pipe. Not readable.'));
+	};
+
+
+	function writeAfterEnd(stream, state, cb) {
+	  var er = new Error('write after end');
+	  // TODO: defer error events consistently everywhere, not just the cb
+	  stream.emit('error', er);
+	  process.nextTick(function() {
+	    cb(er);
+	  });
+	}
+
+	// If we get something that is not a buffer, string, null, or undefined,
+	// and we're not in objectMode, then that's an error.
+	// Otherwise stream chunks are all considered to be of length=1, and the
+	// watermarks determine how many objects to keep in the buffer, rather than
+	// how many bytes or characters.
+	function validChunk(stream, state, chunk, cb) {
+	  var valid = true;
+	  if (!util.isBuffer(chunk) &&
+	      !util.isString(chunk) &&
+	      !util.isNullOrUndefined(chunk) &&
+	      !state.objectMode) {
+	    var er = new TypeError('Invalid non-string/buffer chunk');
+	    stream.emit('error', er);
+	    process.nextTick(function() {
+	      cb(er);
+	    });
+	    valid = false;
+	  }
+	  return valid;
+	}
+
+	Writable.prototype.write = function(chunk, encoding, cb) {
+	  var state = this._writableState;
+	  var ret = false;
+
+	  if (util.isFunction(encoding)) {
+	    cb = encoding;
+	    encoding = null;
+	  }
+
+	  if (util.isBuffer(chunk))
+	    encoding = 'buffer';
+	  else if (!encoding)
+	    encoding = state.defaultEncoding;
+
+	  if (!util.isFunction(cb))
+	    cb = function() {};
+
+	  if (state.ended)
+	    writeAfterEnd(this, state, cb);
+	  else if (validChunk(this, state, chunk, cb)) {
+	    state.pendingcb++;
+	    ret = writeOrBuffer(this, state, chunk, encoding, cb);
+	  }
+
+	  return ret;
+	};
+
+	Writable.prototype.cork = function() {
+	  var state = this._writableState;
+
+	  state.corked++;
+	};
+
+	Writable.prototype.uncork = function() {
+	  var state = this._writableState;
+
+	  if (state.corked) {
+	    state.corked--;
+
+	    if (!state.writing &&
+	        !state.corked &&
+	        !state.finished &&
+	        !state.bufferProcessing &&
+	        state.buffer.length)
+	      clearBuffer(this, state);
+	  }
+	};
+
+	function decodeChunk(state, chunk, encoding) {
+	  if (!state.objectMode &&
+	      state.decodeStrings !== false &&
+	      util.isString(chunk)) {
+	    chunk = new Buffer(chunk, encoding);
+	  }
+	  return chunk;
+	}
+
+	// if we're already writing something, then just put this
+	// in the queue, and wait our turn.  Otherwise, call _write
+	// If we return false, then we need a drain event, so set that flag.
+	function writeOrBuffer(stream, state, chunk, encoding, cb) {
+	  chunk = decodeChunk(state, chunk, encoding);
+	  if (util.isBuffer(chunk))
+	    encoding = 'buffer';
+	  var len = state.objectMode ? 1 : chunk.length;
+
+	  state.length += len;
+
+	  var ret = state.length < state.highWaterMark;
+	  // we must ensure that previous needDrain will not be reset to false.
+	  if (!ret)
+	    state.needDrain = true;
+
+	  if (state.writing || state.corked)
+	    state.buffer.push(new WriteReq(chunk, encoding, cb));
+	  else
+	    doWrite(stream, state, false, len, chunk, encoding, cb);
+
+	  return ret;
+	}
+
+	function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+	  state.writelen = len;
+	  state.writecb = cb;
+	  state.writing = true;
+	  state.sync = true;
+	  if (writev)
+	    stream._writev(chunk, state.onwrite);
+	  else
+	    stream._write(chunk, encoding, state.onwrite);
+	  state.sync = false;
+	}
+
+	function onwriteError(stream, state, sync, er, cb) {
+	  if (sync)
+	    process.nextTick(function() {
+	      state.pendingcb--;
+	      cb(er);
+	    });
+	  else {
+	    state.pendingcb--;
+	    cb(er);
+	  }
+
+	  stream._writableState.errorEmitted = true;
+	  stream.emit('error', er);
+	}
+
+	function onwriteStateUpdate(state) {
+	  state.writing = false;
+	  state.writecb = null;
+	  state.length -= state.writelen;
+	  state.writelen = 0;
+	}
+
+	function onwrite(stream, er) {
+	  var state = stream._writableState;
+	  var sync = state.sync;
+	  var cb = state.writecb;
+
+	  onwriteStateUpdate(state);
+
+	  if (er)
+	    onwriteError(stream, state, sync, er, cb);
+	  else {
+	    // Check if we're actually ready to finish, but don't emit yet
+	    var finished = needFinish(stream, state);
+
+	    if (!finished &&
+	        !state.corked &&
+	        !state.bufferProcessing &&
+	        state.buffer.length) {
+	      clearBuffer(stream, state);
+	    }
+
+	    if (sync) {
+	      process.nextTick(function() {
+	        afterWrite(stream, state, finished, cb);
+	      });
+	    } else {
+	      afterWrite(stream, state, finished, cb);
+	    }
+	  }
+	}
+
+	function afterWrite(stream, state, finished, cb) {
+	  if (!finished)
+	    onwriteDrain(stream, state);
+	  state.pendingcb--;
+	  cb();
+	  finishMaybe(stream, state);
+	}
+
+	// Must force callback to be called on nextTick, so that we don't
+	// emit 'drain' before the write() consumer gets the 'false' return
+	// value, and has a chance to attach a 'drain' listener.
+	function onwriteDrain(stream, state) {
+	  if (state.length === 0 && state.needDrain) {
+	    state.needDrain = false;
+	    stream.emit('drain');
+	  }
+	}
+
+
+	// if there's something in the buffer waiting, then process it
+	function clearBuffer(stream, state) {
+	  state.bufferProcessing = true;
+
+	  if (stream._writev && state.buffer.length > 1) {
+	    // Fast case, write everything using _writev()
+	    var cbs = [];
+	    for (var c = 0; c < state.buffer.length; c++)
+	      cbs.push(state.buffer[c].callback);
+
+	    // count the one we are adding, as well.
+	    // TODO(isaacs) clean this up
+	    state.pendingcb++;
+	    doWrite(stream, state, true, state.length, state.buffer, '', function(err) {
+	      for (var i = 0; i < cbs.length; i++) {
+	        state.pendingcb--;
+	        cbs[i](err);
+	      }
+	    });
+
+	    // Clear buffer
+	    state.buffer = [];
+	  } else {
+	    // Slow case, write chunks one-by-one
+	    for (var c = 0; c < state.buffer.length; c++) {
+	      var entry = state.buffer[c];
+	      var chunk = entry.chunk;
+	      var encoding = entry.encoding;
+	      var cb = entry.callback;
+	      var len = state.objectMode ? 1 : chunk.length;
+
+	      doWrite(stream, state, false, len, chunk, encoding, cb);
+
+	      // if we didn't call the onwrite immediately, then
+	      // it means that we need to wait until it does.
+	      // also, that means that the chunk and cb are currently
+	      // being processed, so move the buffer counter past them.
+	      if (state.writing) {
+	        c++;
+	        break;
+	      }
+	    }
+
+	    if (c < state.buffer.length)
+	      state.buffer = state.buffer.slice(c);
+	    else
+	      state.buffer.length = 0;
+	  }
+
+	  state.bufferProcessing = false;
+	}
+
+	Writable.prototype._write = function(chunk, encoding, cb) {
+	  cb(new Error('not implemented'));
+
+	};
+
+	Writable.prototype._writev = null;
+
+	Writable.prototype.end = function(chunk, encoding, cb) {
+	  var state = this._writableState;
+
+	  if (util.isFunction(chunk)) {
+	    cb = chunk;
+	    chunk = null;
+	    encoding = null;
+	  } else if (util.isFunction(encoding)) {
+	    cb = encoding;
+	    encoding = null;
+	  }
+
+	  if (!util.isNullOrUndefined(chunk))
+	    this.write(chunk, encoding);
+
+	  // .end() fully uncorks
+	  if (state.corked) {
+	    state.corked = 1;
+	    this.uncork();
+	  }
+
+	  // ignore unnecessary end() calls.
+	  if (!state.ending && !state.finished)
+	    endWritable(this, state, cb);
+	};
+
+
+	function needFinish(stream, state) {
+	  return (state.ending &&
+	          state.length === 0 &&
+	          !state.finished &&
+	          !state.writing);
+	}
+
+	function prefinish(stream, state) {
+	  if (!state.prefinished) {
+	    state.prefinished = true;
+	    stream.emit('prefinish');
+	  }
+	}
+
+	function finishMaybe(stream, state) {
+	  var need = needFinish(stream, state);
+	  if (need) {
+	    if (state.pendingcb === 0) {
+	      prefinish(stream, state);
+	      state.finished = true;
+	      stream.emit('finish');
+	    } else
+	      prefinish(stream, state);
+	  }
+	  return need;
+	}
+
+	function endWritable(stream, state, cb) {
+	  state.ending = true;
+	  finishMaybe(stream, state);
+	  if (cb) {
+	    if (state.finished)
+	      process.nextTick(cb);
+	    else
+	      stream.once('finish', cb);
+	  }
+	  state.ended = true;
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 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 Buffer = __webpack_require__(28).Buffer;
+
+	var isBufferEncoding = Buffer.isEncoding
+	  || function(encoding) {
+	       switch (encoding && encoding.toLowerCase()) {
+	         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+	         default: return false;
+	       }
+	     }
+
+
+	function assertEncoding(encoding) {
+	  if (encoding && !isBufferEncoding(encoding)) {
+	    throw new Error('Unknown encoding: ' + encoding);
+	  }
+	}
+
+	// StringDecoder provides an interface for efficiently splitting a series of
+	// buffers into a series of JS strings without breaking apart multi-byte
+	// characters. CESU-8 is handled as part of the UTF-8 encoding.
+	//
+	// @TODO Handling all encodings inside a single object makes it very difficult
+	// to reason about this code, so it should be split up in the future.
+	// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+	// points as used by CESU-8.
+	var StringDecoder = exports.StringDecoder = function(encoding) {
+	  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+	  assertEncoding(encoding);
+	  switch (this.encoding) {
+	    case 'utf8':
+	      // CESU-8 represents each of Surrogate Pair by 3-bytes
+	      this.surrogateSize = 3;
+	      break;
+	    case 'ucs2':
+	    case 'utf16le':
+	      // UTF-16 represents each of Surrogate Pair by 2-bytes
+	      this.surrogateSize = 2;
+	      this.detectIncompleteChar = utf16DetectIncompleteChar;
+	      break;
+	    case 'base64':
+	      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+	      this.surrogateSize = 3;
+	      this.detectIncompleteChar = base64DetectIncompleteChar;
+	      break;
+	    default:
+	      this.write = passThroughWrite;
+	      return;
+	  }
+
+	  // Enough space to store all bytes of a single character. UTF-8 needs 4
+	  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+	  this.charBuffer = new Buffer(6);
+	  // Number of bytes received for the current incomplete multi-byte character.
+	  this.charReceived = 0;
+	  // Number of bytes expected for the current incomplete multi-byte character.
+	  this.charLength = 0;
+	};
+
+
+	// write decodes the given buffer and returns it as JS string that is
+	// guaranteed to not contain any partial multi-byte characters. Any partial
+	// character found at the end of the buffer is buffered up, and will be
+	// returned when calling write again with the remaining bytes.
+	//
+	// Note: Converting a Buffer containing an orphan surrogate to a String
+	// currently works, but converting a String to a Buffer (via `new Buffer`, or
+	// Buffer#write) will replace incomplete surrogates with the unicode
+	// replacement character. See https://codereview.chromium.org/121173009/ .
+	StringDecoder.prototype.write = function(buffer) {
+	  var charStr = '';
+	  // if our last write ended with an incomplete multibyte character
+	  while (this.charLength) {
+	    // determine how many remaining bytes this buffer has to offer for this char
+	    var available = (buffer.length >= this.charLength - this.charReceived) ?
+	        this.charLength - this.charReceived :
+	        buffer.length;
+
+	    // add the new bytes to the char buffer
+	    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+	    this.charReceived += available;
+
+	    if (this.charReceived < this.charLength) {
+	      // still not enough chars in this buffer? wait for more ...
+	      return '';
+	    }
+
+	    // remove bytes belonging to the current character from the buffer
+	    buffer = buffer.slice(available, buffer.length);
+
+	    // get the character that was split
+	    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+	    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+	    var charCode = charStr.charCodeAt(charStr.length - 1);
+	    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+	      this.charLength += this.surrogateSize;
+	      charStr = '';
+	      continue;
+	    }
+	    this.charReceived = this.charLength = 0;
+
+	    // if there are no more bytes in this buffer, just emit our char
+	    if (buffer.length === 0) {
+	      return charStr;
+	    }
+	    break;
+	  }
+
+	  // determine and set charLength / charReceived
+	  this.detectIncompleteChar(buffer);
+
+	  var end = buffer.length;
+	  if (this.charLength) {
+	    // buffer the incomplete character bytes we got
+	    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+	    end -= this.charReceived;
+	  }
+
+	  charStr += buffer.toString(this.encoding, 0, end);
+
+	  var end = charStr.length - 1;
+	  var charCode = charStr.charCodeAt(end);
+	  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+	  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+	    var size = this.surrogateSize;
+	    this.charLength += size;
+	    this.charReceived += size;
+	    this.charBuffer.copy(this.charBuffer, size, 0, size);
+	    buffer.copy(this.charBuffer, 0, 0, size);
+	    return charStr.substring(0, end);
+	  }
+
+	  // or just emit the charStr
+	  return charStr;
+	};
+
+	// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+	// the end of the given buffer. If so, it sets this.charLength to the byte
+	// length that character, and sets this.charReceived to the number of bytes
+	// that are available for this character.
+	StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+	  // determine how many bytes we have to check at the end of this buffer
+	  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+	  // Figure out if one of the last i bytes of our buffer announces an
+	  // incomplete char.
+	  for (; i > 0; i--) {
+	    var c = buffer[buffer.length - i];
+
+	    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+	    // 110XXXXX
+	    if (i == 1 && c >> 5 == 0x06) {
+	      this.charLength = 2;
+	      break;
+	    }
+
+	    // 1110XXXX
+	    if (i <= 2 && c >> 4 == 0x0E) {
+	      this.charLength = 3;
+	      break;
+	    }
+
+	    // 11110XXX
+	    if (i <= 3 && c >> 3 == 0x1E) {
+	      this.charLength = 4;
+	      break;
+	    }
+	  }
+	  this.charReceived = i;
+	};
+
+	StringDecoder.prototype.end = function(buffer) {
+	  var res = '';
+	  if (buffer && buffer.length)
+	    res = this.write(buffer);
+
+	  if (this.charReceived) {
+	    var cr = this.charReceived;
+	    var buf = this.charBuffer;
+	    var enc = this.encoding;
+	    res += buf.slice(0, cr).toString(enc);
+	  }
+
+	  return res;
+	};
+
+	function passThroughWrite(buffer) {
+	  return buffer.toString(this.encoding);
+	}
+
+	function utf16DetectIncompleteChar(buffer) {
+	  this.charReceived = buffer.length % 2;
+	  this.charLength = this.charReceived ? 2 : 0;
+	}
+
+	function base64DetectIncompleteChar(buffer) {
+	  this.charReceived = buffer.length % 3;
+	  this.charLength = this.charReceived ? 3 : 0;
+	}
+
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 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.
+
+
+	// a transform stream is a readable/writable stream where you do
+	// something with the data.  Sometimes it's called a "filter",
+	// but that's not a great name for it, since that implies a thing where
+	// some bits pass through, and others are simply ignored.  (That would
+	// be a valid example of a transform, of course.)
+	//
+	// While the output is causally related to the input, it's not a
+	// necessarily symmetric or synchronous transformation.  For example,
+	// a zlib stream might take multiple plain-text writes(), and then
+	// emit a single compressed chunk some time in the future.
+	//
+	// Here's how this works:
+	//
+	// The Transform stream has all the aspects of the readable and writable
+	// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+	// internally, and returns false if there's a lot of pending writes
+	// buffered up.  When you call read(), that calls _read(n) until
+	// there's enough pending readable data buffered up.
+	//
+	// In a transform stream, the written data is placed in a buffer.  When
+	// _read(n) is called, it transforms the queued up data, calling the
+	// buffered _write cb's as it consumes chunks.  If consuming a single
+	// written chunk would result in multiple output chunks, then the first
+	// outputted bit calls the readcb, and subsequent chunks just go into
+	// the read buffer, and will cause it to emit 'readable' if necessary.
+	//
+	// This way, back-pressure is actually determined by the reading side,
+	// since _read has to be called to start processing a new chunk.  However,
+	// a pathological inflate type of transform can cause excessive buffering
+	// here.  For example, imagine a stream where every byte of input is
+	// interpreted as an integer from 0-255, and then results in that many
+	// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+	// 1kb of data being output.  In this case, you could write a very small
+	// amount of input, and end up with a very large amount of output.  In
+	// such a pathological inflating mechanism, there'd be no way to tell
+	// the system to stop doing the transform.  A single 4MB write could
+	// cause the system to run out of memory.
+	//
+	// However, even in such a pathological case, only a single written chunk
+	// would be consumed, and then the rest would wait (un-transformed) until
+	// the results of the previous transformed chunk were consumed.
+
+	module.exports = Transform;
+
+	var Duplex = __webpack_require__(35);
+
+	/*<replacement>*/
+	var util = __webpack_require__(32);
+	util.inherits = __webpack_require__(33);
+	/*</replacement>*/
+
+	util.inherits(Transform, Duplex);
+
+
+	function TransformState(options, stream) {
+	  this.afterTransform = function(er, data) {
+	    return afterTransform(stream, er, data);
+	  };
+
+	  this.needTransform = false;
+	  this.transforming = false;
+	  this.writecb = null;
+	  this.writechunk = null;
+	}
+
+	function afterTransform(stream, er, data) {
+	  var ts = stream._transformState;
+	  ts.transforming = false;
+
+	  var cb = ts.writecb;
+
+	  if (!cb)
+	    return stream.emit('error', new Error('no writecb in Transform class'));
+
+	  ts.writechunk = null;
+	  ts.writecb = null;
+
+	  if (!util.isNullOrUndefined(data))
+	    stream.push(data);
+
+	  if (cb)
+	    cb(er);
+
+	  var rs = stream._readableState;
+	  rs.reading = false;
+	  if (rs.needReadable || rs.length < rs.highWaterMark) {
+	    stream._read(rs.highWaterMark);
+	  }
+	}
+
+
+	function Transform(options) {
+	  if (!(this instanceof Transform))
+	    return new Transform(options);
+
+	  Duplex.call(this, options);
+
+	  this._transformState = new TransformState(options, this);
+
+	  // when the writable side finishes, then flush out anything remaining.
+	  var stream = this;
+
+	  // start out asking for a readable event once data is transformed.
+	  this._readableState.needReadable = true;
+
+	  // we have implemented the _read method, and done the other things
+	  // that Readable wants before the first _read call, so unset the
+	  // sync guard flag.
+	  this._readableState.sync = false;
+
+	  this.once('prefinish', function() {
+	    if (util.isFunction(this._flush))
+	      this._flush(function(er) {
+	        done(stream, er);
+	      });
+	    else
+	      done(stream);
+	  });
+	}
+
+	Transform.prototype.push = function(chunk, encoding) {
+	  this._transformState.needTransform = false;
+	  return Duplex.prototype.push.call(this, chunk, encoding);
+	};
+
+	// This is the part where you do stuff!
+	// override this function in implementation classes.
+	// 'chunk' is an input chunk.
+	//
+	// Call `push(newChunk)` to pass along transformed output
+	// to the readable side.  You may call 'push' zero or more times.
+	//
+	// Call `cb(err)` when you are done with this chunk.  If you pass
+	// an error, then that'll put the hurt on the whole operation.  If you
+	// never call cb(), then you'll never get another chunk.
+	Transform.prototype._transform = function(chunk, encoding, cb) {
+	  throw new Error('not implemented');
+	};
+
+	Transform.prototype._write = function(chunk, encoding, cb) {
+	  var ts = this._transformState;
+	  ts.writecb = cb;
+	  ts.writechunk = chunk;
+	  ts.writeencoding = encoding;
+	  if (!ts.transforming) {
+	    var rs = this._readableState;
+	    if (ts.needTransform ||
+	        rs.needReadable ||
+	        rs.length < rs.highWaterMark)
+	      this._read(rs.highWaterMark);
+	  }
+	};
+
+	// Doesn't matter what the args are here.
+	// _transform does all the work.
+	// That we got here means that the readable side wants more data.
+	Transform.prototype._read = function(n) {
+	  var ts = this._transformState;
+
+	  if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) {
+	    ts.transforming = true;
+	    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+	  } else {
+	    // mark that we need a transform, so that any data that comes in
+	    // will get processed, now that we've asked for it.
+	    ts.needTransform = true;
+	  }
+	};
+
+
+	function done(stream, er) {
+	  if (er)
+	    return stream.emit('error', er);
+
+	  // if there's nothing in the write buffer, then that means
+	  // that nothing more will ever be provided
+	  var ws = stream._writableState;
+	  var ts = stream._transformState;
+
+	  if (ws.length)
+	    throw new Error('calling transform done when ws.length != 0');
+
+	  if (ts.transforming)
+	    throw new Error('calling transform done when still transforming');
+
+	  return stream.push(null);
+	}
+
+
+/***/ },
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// 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.
+
+	// a passthrough stream.
+	// basically just the most minimal sort of Transform stream.
+	// Every written chunk gets output as-is.
+
+	module.exports = PassThrough;
+
+	var Transform = __webpack_require__(38);
+
+	/*<replacement>*/
+	var util = __webpack_require__(32);
+	util.inherits = __webpack_require__(33);
+	/*</replacement>*/
+
+	util.inherits(PassThrough, Transform);
+
+	function PassThrough(options) {
+	  if (!(this instanceof PassThrough))
+	    return new PassThrough(options);
+
+	  Transform.call(this, options);
+	}
+
+	PassThrough.prototype._transform = function(chunk, encoding, cb) {
+	  cb(null, chunk);
+	};
+
+
+/***/ },
+/* 40 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(36)
+
+
+/***/ },
+/* 41 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(35)
+
+
+/***/ },
+/* 42 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(38)
+
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(39)
+
+
+/***/ },
+/* 44 */
+/***/ function(module, exports) {
+
+	/* (ignored) */
+
+/***/ },
+/* 45 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = ProxyHandler;
+
+	function ProxyHandler(cbs){
+		this._cbs = cbs || {};
+	}
+
+	var EVENTS = __webpack_require__(8).EVENTS;
+	Object.keys(EVENTS).forEach(function(name){
+		if(EVENTS[name] === 0){
+			name = "on" + name;
+			ProxyHandler.prototype[name] = function(){
+				if(this._cbs[name]) this._cbs[name]();
+			};
+		} else if(EVENTS[name] === 1){
+			name = "on" + name;
+			ProxyHandler.prototype[name] = function(a){
+				if(this._cbs[name]) this._cbs[name](a);
+			};
+		} else if(EVENTS[name] === 2){
+			name = "on" + name;
+			ProxyHandler.prototype[name] = function(a, b){
+				if(this._cbs[name]) this._cbs[name](a, b);
+			};
+		} else {
+			throw Error("wrong number of arguments");
+		}
+	});
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var DomUtils = module.exports;
+
+	[
+		__webpack_require__(47),
+		__webpack_require__(53),
+		__webpack_require__(54),
+		__webpack_require__(55),
+		__webpack_require__(56),
+		__webpack_require__(57)
+	].forEach(function(ext){
+		Object.keys(ext).forEach(function(key){
+			DomUtils[key] = ext[key].bind(DomUtils);
+		});
+	});
+
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var ElementType = __webpack_require__(17),
+	    getOuterHTML = __webpack_require__(48),
+	    isTag = ElementType.isTag;
+
+	module.exports = {
+		getInnerHTML: getInnerHTML,
+		getOuterHTML: getOuterHTML,
+		getText: getText
+	};
+
+	function getInnerHTML(elem, opts){
+		return elem.children ? elem.children.map(function(elem){
+			return getOuterHTML(elem, opts);
+		}).join("") : "";
+	}
+
+	function getText(elem){
+		if(Array.isArray(elem)) return elem.map(getText).join("");
+		if(isTag(elem) || elem.type === ElementType.CDATA) return getText(elem.children);
+		if(elem.type === ElementType.Text) return elem.data;
+		return "";
+	}
+
+
+/***/ },
+/* 48 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/*
+	  Module dependencies
+	*/
+	var ElementType = __webpack_require__(49);
+	var entities = __webpack_require__(50);
+
+	/*
+	  Boolean Attributes
+	*/
+	var booleanAttributes = {
+	  __proto__: null,
+	  allowfullscreen: true,
+	  async: true,
+	  autofocus: true,
+	  autoplay: true,
+	  checked: true,
+	  controls: true,
+	  default: true,
+	  defer: true,
+	  disabled: true,
+	  hidden: true,
+	  ismap: true,
+	  loop: true,
+	  multiple: true,
+	  muted: true,
+	  open: true,
+	  readonly: true,
+	  required: true,
+	  reversed: true,
+	  scoped: true,
+	  seamless: true,
+	  selected: true,
+	  typemustmatch: true
+	};
+
+	var unencodedElements = {
+	  __proto__: null,
+	  style: true,
+	  script: true,
+	  xmp: true,
+	  iframe: true,
+	  noembed: true,
+	  noframes: true,
+	  plaintext: true,
+	  noscript: true
+	};
+
+	/*
+	  Format attributes
+	*/
+	function formatAttrs(attributes, opts) {
+	  if (!attributes) return;
+
+	  var output = '',
+	      value;
+
+	  // Loop through the attributes
+	  for (var key in attributes) {
+	    value = attributes[key];
+	    if (output) {
+	      output += ' ';
+	    }
+
+	    if (!value && booleanAttributes[key]) {
+	      output += key;
+	    } else {
+	      output += key + '="' + (opts.decodeEntities ? entities.encodeXML(value) : value) + '"';
+	    }
+	  }
+
+	  return output;
+	}
+
+	/*
+	  Self-enclosing tags (stolen from node-htmlparser)
+	*/
+	var singleTag = {
+	  __proto__: null,
+	  area: true,
+	  base: true,
+	  basefont: true,
+	  br: true,
+	  col: true,
+	  command: true,
+	  embed: true,
+	  frame: true,
+	  hr: true,
+	  img: true,
+	  input: true,
+	  isindex: true,
+	  keygen: true,
+	  link: true,
+	  meta: true,
+	  param: true,
+	  source: true,
+	  track: true,
+	  wbr: true,
+	};
+
+
+	var render = module.exports = function(dom, opts) {
+	  if (!Array.isArray(dom) && !dom.cheerio) dom = [dom];
+	  opts = opts || {};
+
+	  var output = '';
+
+	  for(var i = 0; i < dom.length; i++){
+	    var elem = dom[i];
+
+	    if (elem.type === 'root')
+	      output += render(elem.children, opts);
+	    else if (ElementType.isTag(elem))
+	      output += renderTag(elem, opts);
+	    else if (elem.type === ElementType.Directive)
+	      output += renderDirective(elem);
+	    else if (elem.type === ElementType.Comment)
+	      output += renderComment(elem);
+	    else if (elem.type === ElementType.CDATA)
+	      output += renderCdata(elem);
+	    else
+	      output += renderText(elem, opts);
+	  }
+
+	  return output;
+	};
+
+	function renderTag(elem, opts) {
+	  // Handle SVG
+	  if (elem.name === "svg") opts = {decodeEntities: opts.decodeEntities, xmlMode: true};
+
+	  var tag = '<' + elem.name,
+	      attribs = formatAttrs(elem.attribs, opts);
+
+	  if (attribs) {
+	    tag += ' ' + attribs;
+	  }
+
+	  if (
+	    opts.xmlMode
+	    && (!elem.children || elem.children.length === 0)
+	  ) {
+	    tag += '/>';
+	  } else {
+	    tag += '>';
+	    if (elem.children) {
+	      tag += render(elem.children, opts);
+	    }
+
+	    if (!singleTag[elem.name] || opts.xmlMode) {
+	      tag += '</' + elem.name + '>';
+	    }
+	  }
+
+	  return tag;
+	}
+
+	function renderDirective(elem) {
+	  return '<' + elem.data + '>';
+	}
+
+	function renderText(elem, opts) {
+	  var data = elem.data || '';
+
+	  // if entities weren't decoded, no need to encode them back
+	  if (opts.decodeEntities && !(elem.parent && elem.parent.name in unencodedElements)) {
+	    data = entities.encodeXML(data);
+	  }
+
+	  return data;
+	}
+
+	function renderCdata(elem) {
+	  return '<![CDATA[' + elem.children[0].data + ']]>';
+	}
+
+	function renderComment(elem) {
+	  return '<!--' + elem.data + '-->';
+	}
+
+
+/***/ },
+/* 49 */
+/***/ function(module, exports) {
+
+	//Types of elements found in the DOM
+	module.exports = {
+		Text: "text", //Text
+		Directive: "directive", //<? ... ?>
+		Comment: "comment", //<!-- ... -->
+		Script: "script", //<script> tags
+		Style: "style", //<style> tags
+		Tag: "tag", //Any tag
+		CDATA: "cdata", //<![CDATA[ ... ]]>
+
+		isTag: function(elem){
+			return elem.type === "tag" || elem.type === "script" || elem.type === "style";
+		}
+	};
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var encode = __webpack_require__(51),
+	    decode = __webpack_require__(52);
+
+	exports.decode = function(data, level){
+		return (!level || level <= 0 ? decode.XML : decode.HTML)(data);
+	};
+
+	exports.decodeStrict = function(data, level){
+		return (!level || level <= 0 ? decode.XML : decode.HTMLStrict)(data);
+	};
+
+	exports.encode = function(data, level){
+		return (!level || level <= 0 ? encode.XML : encode.HTML)(data);
+	};
+
+	exports.encodeXML = encode.XML;
+
+	exports.encodeHTML4 =
+	exports.encodeHTML5 =
+	exports.encodeHTML  = encode.HTML;
+
+	exports.decodeXML =
+	exports.decodeXMLStrict = decode.XML;
+
+	exports.decodeHTML4 =
+	exports.decodeHTML5 =
+	exports.decodeHTML = decode.HTML;
+
+	exports.decodeHTML4Strict =
+	exports.decodeHTML5Strict =
+	exports.decodeHTMLStrict = decode.HTMLStrict;
+
+	exports.escape = encode.escape;
+
+
+/***/ },
+/* 51 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var inverseXML = getInverseObj(__webpack_require__(15)),
+	    xmlReplacer = getInverseReplacer(inverseXML);
+
+	exports.XML = getInverse(inverseXML, xmlReplacer);
+
+	var inverseHTML = getInverseObj(__webpack_require__(13)),
+	    htmlReplacer = getInverseReplacer(inverseHTML);
+
+	exports.HTML = getInverse(inverseHTML, htmlReplacer);
+
+	function getInverseObj(obj){
+		return Object.keys(obj).sort().reduce(function(inverse, name){
+			inverse[obj[name]] = "&" + name + ";";
+			return inverse;
+		}, {});
+	}
+
+	function getInverseReplacer(inverse){
+		var single = [],
+		    multiple = [];
+
+		Object.keys(inverse).forEach(function(k){
+			if(k.length === 1){
+				single.push("\\" + k);
+			} else {
+				multiple.push(k);
+			}
+		});
+
+		//TODO add ranges
+		multiple.unshift("[" + single.join("") + "]");
+
+		return new RegExp(multiple.join("|"), "g");
+	}
+
+	var re_nonASCII = /[^\0-\x7F]/g,
+	    re_astralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+
+	function singleCharReplacer(c){
+		return "&#x" + c.charCodeAt(0).toString(16).toUpperCase() + ";";
+	}
+
+	function astralReplacer(c){
+		// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+		var high = c.charCodeAt(0);
+		var low  = c.charCodeAt(1);
+		var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+		return "&#x" + codePoint.toString(16).toUpperCase() + ";";
+	}
+
+	function getInverse(inverse, re){
+		function func(name){
+			return inverse[name];
+		}
+
+		return function(data){
+			return data
+					.replace(re, func)
+					.replace(re_astralSymbols, astralReplacer)
+					.replace(re_nonASCII, singleCharReplacer);
+		};
+	}
+
+	var re_xmlChars = getInverseReplacer(inverseXML);
+
+	function escapeXML(data){
+		return data
+				.replace(re_xmlChars, singleCharReplacer)
+				.replace(re_astralSymbols, astralReplacer)
+				.replace(re_nonASCII, singleCharReplacer);
+	}
+
+	exports.escape = escapeXML;
+
+
+/***/ },
+/* 52 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var entityMap = __webpack_require__(13),
+	    legacyMap = __webpack_require__(14),
+	    xmlMap    = __webpack_require__(15),
+	    decodeCodePoint = __webpack_require__(11);
+
+	var decodeXMLStrict  = getStrictDecoder(xmlMap),
+	    decodeHTMLStrict = getStrictDecoder(entityMap);
+
+	function getStrictDecoder(map){
+		var keys = Object.keys(map).join("|"),
+		    replace = getReplacer(map);
+
+		keys += "|#[xX][\\da-fA-F]+|#\\d+";
+
+		var re = new RegExp("&(?:" + keys + ");", "g");
+
+		return function(str){
+			return String(str).replace(re, replace);
+		};
+	}
+
+	var decodeHTML = (function(){
+		var legacy = Object.keys(legacyMap)
+			.sort(sorter);
+
+		var keys = Object.keys(entityMap)
+			.sort(sorter);
+
+		for(var i = 0, j = 0; i < keys.length; i++){
+			if(legacy[j] === keys[i]){
+				keys[i] += ";?";
+				j++;
+			} else {
+				keys[i] += ";";
+			}
+		}
+
+		var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g"),
+		    replace = getReplacer(entityMap);
+
+		function replacer(str){
+			if(str.substr(-1) !== ";") str += ";";
+			return replace(str);
+		}
+
+		//TODO consider creating a merged map
+		return function(str){
+			return String(str).replace(re, replacer);
+		};
+	}());
+
+	function sorter(a, b){
+		return a < b ? 1 : -1;
+	}
+
+	function getReplacer(map){
+		return function replace(str){
+			if(str.charAt(1) === "#"){
+				if(str.charAt(2) === "X" || str.charAt(2) === "x"){
+					return decodeCodePoint(parseInt(str.substr(3), 16));
+				}
+				return decodeCodePoint(parseInt(str.substr(2), 10));
+			}
+			return map[str.slice(1, -1)];
+		};
+	}
+
+	module.exports = {
+		XML: decodeXMLStrict,
+		HTML: decodeHTML,
+		HTMLStrict: decodeHTMLStrict
+	};
+
+/***/ },
+/* 53 */
+/***/ function(module, exports) {
+
+	var getChildren = exports.getChildren = function(elem){
+		return elem.children;
+	};
+
+	var getParent = exports.getParent = function(elem){
+		return elem.parent;
+	};
+
+	exports.getSiblings = function(elem){
+		var parent = getParent(elem);
+		return parent ? getChildren(parent) : [elem];
+	};
+
+	exports.getAttributeValue = function(elem, name){
+		return elem.attribs && elem.attribs[name];
+	};
+
+	exports.hasAttrib = function(elem, name){
+		return !!elem.attribs && hasOwnProperty.call(elem.attribs, name);
+	};
+
+	exports.getName = function(elem){
+		return elem.name;
+	};
+
+
+/***/ },
+/* 54 */
+/***/ function(module, exports) {
+
+	exports.removeElement = function(elem){
+		if(elem.prev) elem.prev.next = elem.next;
+		if(elem.next) elem.next.prev = elem.prev;
+
+		if(elem.parent){
+			var childs = elem.parent.children;
+			childs.splice(childs.lastIndexOf(elem), 1);
+		}
+	};
+
+	exports.replaceElement = function(elem, replacement){
+		var prev = replacement.prev = elem.prev;
+		if(prev){
+			prev.next = replacement;
+		}
+
+		var next = replacement.next = elem.next;
+		if(next){
+			next.prev = replacement;
+		}
+
+		var parent = replacement.parent = elem.parent;
+		if(parent){
+			var childs = parent.children;
+			childs[childs.lastIndexOf(elem)] = replacement;
+		}
+	};
+
+	exports.appendChild = function(elem, child){
+		child.parent = elem;
+
+		if(elem.children.push(child) !== 1){
+			var sibling = elem.children[elem.children.length - 2];
+			sibling.next = child;
+			child.prev = sibling;
+			child.next = null;
+		}
+	};
+
+	exports.append = function(elem, next){
+		var parent = elem.parent,
+			currNext = elem.next;
+
+		next.next = currNext;
+		next.prev = elem;
+		elem.next = next;
+		next.parent = parent;
+
+		if(currNext){
+			currNext.prev = next;
+			if(parent){
+				var childs = parent.children;
+				childs.splice(childs.lastIndexOf(currNext), 0, next);
+			}
+		} else if(parent){
+			parent.children.push(next);
+		}
+	};
+
+	exports.prepend = function(elem, prev){
+		var parent = elem.parent;
+		if(parent){
+			var childs = parent.children;
+			childs.splice(childs.lastIndexOf(elem), 0, prev);
+		}
+
+		if(elem.prev){
+			elem.prev.next = prev;
+		}
+		
+		prev.parent = parent;
+		prev.prev = elem.prev;
+		prev.next = elem;
+		elem.prev = prev;
+	};
+
+
+
+
+/***/ },
+/* 55 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isTag = __webpack_require__(17).isTag;
+
+	module.exports = {
+		filter: filter,
+		find: find,
+		findOneChild: findOneChild,
+		findOne: findOne,
+		existsOne: existsOne,
+		findAll: findAll
+	};
+
+	function filter(test, element, recurse, limit){
+		if(!Array.isArray(element)) element = [element];
+
+		if(typeof limit !== "number" || !isFinite(limit)){
+			limit = Infinity;
+		}
+		return find(test, element, recurse !== false, limit);
+	}
+
+	function find(test, elems, recurse, limit){
+		var result = [], childs;
+
+		for(var i = 0, j = elems.length; i < j; i++){
+			if(test(elems[i])){
+				result.push(elems[i]);
+				if(--limit <= 0) break;
+			}
+
+			childs = elems[i].children;
+			if(recurse && childs && childs.length > 0){
+				childs = find(test, childs, recurse, limit);
+				result = result.concat(childs);
+				limit -= childs.length;
+				if(limit <= 0) break;
+			}
+		}
+
+		return result;
+	}
+
+	function findOneChild(test, elems){
+		for(var i = 0, l = elems.length; i < l; i++){
+			if(test(elems[i])) return elems[i];
+		}
+
+		return null;
+	}
+
+	function findOne(test, elems){
+		var elem = null;
+
+		for(var i = 0, l = elems.length; i < l && !elem; i++){
+			if(!isTag(elems[i])){
+				continue;
+			} else if(test(elems[i])){
+				elem = elems[i];
+			} else if(elems[i].children.length > 0){
+				elem = findOne(test, elems[i].children);
+			}
+		}
+
+		return elem;
+	}
+
+	function existsOne(test, elems){
+		for(var i = 0, l = elems.length; i < l; i++){
+			if(
+				isTag(elems[i]) && (
+					test(elems[i]) || (
+						elems[i].children.length > 0 &&
+						existsOne(test, elems[i].children)
+					)
+				)
+			){
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	function findAll(test, elems){
+		var result = [];
+		for(var i = 0, j = elems.length; i < j; i++){
+			if(!isTag(elems[i])) continue;
+			if(test(elems[i])) result.push(elems[i]);
+
+			if(elems[i].children.length > 0){
+				result = result.concat(findAll(test, elems[i].children));
+			}
+		}
+		return result;
+	}
+
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var ElementType = __webpack_require__(17);
+	var isTag = exports.isTag = ElementType.isTag;
+
+	exports.testElement = function(options, element){
+		for(var key in options){
+			if(!options.hasOwnProperty(key));
+			else if(key === "tag_name"){
+				if(!isTag(element) || !options.tag_name(element.name)){
+					return false;
+				}
+			} else if(key === "tag_type"){
+				if(!options.tag_type(element.type)) return false;
+			} else if(key === "tag_contains"){
+				if(isTag(element) || !options.tag_contains(element.data)){
+					return false;
+				}
+			} else if(!element.attribs || !options[key](element.attribs[key])){
+				return false;
+			}
+		}
+		return true;
+	};
+
+	var Checks = {
+		tag_name: function(name){
+			if(typeof name === "function"){
+				return function(elem){ return isTag(elem) && name(elem.name); };
+			} else if(name === "*"){
+				return isTag;
+			} else {
+				return function(elem){ return isTag(elem) && elem.name === name; };
+			}
+		},
+		tag_type: function(type){
+			if(typeof type === "function"){
+				return function(elem){ return type(elem.type); };
+			} else {
+				return function(elem){ return elem.type === type; };
+			}
+		},
+		tag_contains: function(data){
+			if(typeof data === "function"){
+				return function(elem){ return !isTag(elem) && data(elem.data); };
+			} else {
+				return function(elem){ return !isTag(elem) && elem.data === data; };
+			}
+		}
+	};
+
+	function getAttribCheck(attrib, value){
+		if(typeof value === "function"){
+			return function(elem){ return elem.attribs && value(elem.attribs[attrib]); };
+		} else {
+			return function(elem){ return elem.attribs && elem.attribs[attrib] === value; };
+		}
+	}
+
+	function combineFuncs(a, b){
+		return function(elem){
+			return a(elem) || b(elem);
+		};
+	}
+
+	exports.getElements = function(options, element, recurse, limit){
+		var funcs = Object.keys(options).map(function(key){
+			var value = options[key];
+			return key in Checks ? Checks[key](value) : getAttribCheck(key, value);
+		});
+
+		return funcs.length === 0 ? [] : this.filter(
+			funcs.reduce(combineFuncs),
+			element, recurse, limit
+		);
+	};
+
+	exports.getElementById = function(id, element, recurse){
+		if(!Array.isArray(element)) element = [element];
+		return this.findOne(getAttribCheck("id", id), element, recurse !== false);
+	};
+
+	exports.getElementsByTagName = function(name, element, recurse, limit){
+		return this.filter(Checks.tag_name(name), element, recurse, limit);
+	};
+
+	exports.getElementsByTagType = function(type, element, recurse, limit){
+		return this.filter(Checks.tag_type(type), element, recurse, limit);
+	};
+
+
+/***/ },
+/* 57 */
+/***/ function(module, exports) {
+
+	// removeSubsets
+	// Given an array of nodes, remove any member that is contained by another.
+	exports.removeSubsets = function(nodes) {
+		var idx = nodes.length, node, ancestor, replace;
+
+		// Check if each node (or one of its ancestors) is already contained in the
+		// array.
+		while (--idx > -1) {
+			node = ancestor = nodes[idx];
+
+			// Temporarily remove the node under consideration
+			nodes[idx] = null;
+			replace = true;
+
+			while (ancestor) {
+				if (nodes.indexOf(ancestor) > -1) {
+					replace = false;
+					nodes.splice(idx, 1);
+					break;
+				}
+				ancestor = ancestor.parent;
+			}
+
+			// If the node has been found to be unique, re-insert it.
+			if (replace) {
+				nodes[idx] = node;
+			}
+		}
+
+		return nodes;
+	};
+
+	// Source: http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
+	var POSITION = {
+		DISCONNECTED: 1,
+		PRECEDING: 2,
+		FOLLOWING: 4,
+		CONTAINS: 8,
+		CONTAINED_BY: 16
+	};
+
+	// Compare the position of one node against another node in any other document.
+	// The return value is a bitmask with the following values:
+	//
+	// document order:
+	// > There is an ordering, document order, defined on all the nodes in the
+	// > document corresponding to the order in which the first character of the
+	// > XML representation of each node occurs in the XML representation of the
+	// > document after expansion of general entities. Thus, the document element
+	// > node will be the first node. Element nodes occur before their children.
+	// > Thus, document order orders element nodes in order of the occurrence of
+	// > their start-tag in the XML (after expansion of entities). The attribute
+	// > nodes of an element occur after the element and before its children. The
+	// > relative order of attribute nodes is implementation-dependent./
+	// Source:
+	// http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
+	//
+	// @argument {Node} nodaA The first node to use in the comparison
+	// @argument {Node} nodeB The second node to use in the comparison
+	//
+	// @return {Number} A bitmask describing the input nodes' relative position.
+	//         See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
+	//         a description of these values.
+	var comparePos = exports.compareDocumentPosition = function(nodeA, nodeB) {
+		var aParents = [];
+		var bParents = [];
+		var current, sharedParent, siblings, aSibling, bSibling, idx;
+
+		if (nodeA === nodeB) {
+			return 0;
+		}
+
+		current = nodeA;
+		while (current) {
+			aParents.unshift(current);
+			current = current.parent;
+		}
+		current = nodeB;
+		while (current) {
+			bParents.unshift(current);
+			current = current.parent;
+		}
+
+		idx = 0;
+		while (aParents[idx] === bParents[idx]) {
+			idx++;
+		}
+
+		if (idx === 0) {
+			return POSITION.DISCONNECTED;
+		}
+
+		sharedParent = aParents[idx - 1];
+		siblings = sharedParent.children;
+		aSibling = aParents[idx];
+		bSibling = bParents[idx];
+
+		if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
+			if (sharedParent === nodeB) {
+				return POSITION.FOLLOWING | POSITION.CONTAINED_BY;
+			}
+			return POSITION.FOLLOWING;
+		} else {
+			if (sharedParent === nodeA) {
+				return POSITION.PRECEDING | POSITION.CONTAINS;
+			}
+			return POSITION.PRECEDING;
+		}
+	};
+
+	// Sort an array of nodes based on their relative position in the document and
+	// remove any duplicate nodes. If the array contains nodes that do not belong
+	// to the same document, sort order is unspecified.
+	//
+	// @argument {Array} nodes Array of DOM nodes
+	//
+	// @returns {Array} collection of unique nodes, sorted in document order
+	exports.uniqueSort = function(nodes) {
+		var idx = nodes.length, node, position;
+
+		nodes = nodes.slice();
+
+		while (--idx > -1) {
+			node = nodes[idx];
+			position = nodes.indexOf(node);
+			if (position > -1 && position < idx) {
+				nodes.splice(idx, 1);
+			}
+		}
+		nodes.sort(function(a, b) {
+			var relative = comparePos(a, b);
+			if (relative & POSITION.PRECEDING) {
+				return -1;
+			} else if (relative & POSITION.FOLLOWING) {
+				return 1;
+			}
+			return 0;
+		});
+
+		return nodes;
+	};
+
+
+/***/ },
+/* 58 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = CollectingHandler;
+
+	function CollectingHandler(cbs){
+		this._cbs = cbs || {};
+		this.events = [];
+	}
+
+	var EVENTS = __webpack_require__(8).EVENTS;
+	Object.keys(EVENTS).forEach(function(name){
+		if(EVENTS[name] === 0){
+			name = "on" + name;
+			CollectingHandler.prototype[name] = function(){
+				this.events.push([name]);
+				if(this._cbs[name]) this._cbs[name]();
+			};
+		} else if(EVENTS[name] === 1){
+			name = "on" + name;
+			CollectingHandler.prototype[name] = function(a){
+				this.events.push([name, a]);
+				if(this._cbs[name]) this._cbs[name](a);
+			};
+		} else if(EVENTS[name] === 2){
+			name = "on" + name;
+			CollectingHandler.prototype[name] = function(a, b){
+				this.events.push([name, a, b]);
+				if(this._cbs[name]) this._cbs[name](a, b);
+			};
+		} else {
+			throw Error("wrong number of arguments");
+		}
+	});
+
+	CollectingHandler.prototype.onreset = function(){
+		this.events = [];
+		if(this._cbs.onreset) this._cbs.onreset();
+	};
+
+	CollectingHandler.prototype.restart = function(){
+		if(this._cbs.onreset) this._cbs.onreset();
+
+		for(var i = 0, len = this.events.length; i < len; i++){
+			if(this._cbs[this.events[i][0]]){
+
+				var num = this.events[i].length;
+
+				if(num === 1){
+					this._cbs[this.events[i][0]]();
+				} else if(num === 2){
+					this._cbs[this.events[i][0]](this.events[i][1]);
+				} else {
+					this._cbs[this.events[i][0]](this.events[i][1], this.events[i][2]);
+				}
+			}
+		}
+	};
+
+
+/***/ },
+/* 59 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var normalizeOpts = __webpack_require__(60)
+	  , resolveLength = __webpack_require__(61)
+	  , plain         = __webpack_require__(67);
+
+	module.exports = function (fn/*, options*/) {
+		var options = normalizeOpts(arguments[1]), length;
+
+		if (!options.normalizer) {
+			length = options.length = resolveLength(options.length, fn.length, options.async);
+			if (length !== 0) {
+				if (options.primitive) {
+					if (length === false) {
+						options.normalizer = __webpack_require__(104);
+					} else if (length > 1) {
+						options.normalizer = __webpack_require__(105)(length);
+					}
+				} else {
+					if (length === false) options.normalizer = __webpack_require__(106)();
+					else if (length === 1) options.normalizer = __webpack_require__(108)();
+					else options.normalizer = __webpack_require__(109)(length);
+				}
+			}
+		}
+
+		// Assure extensions
+		if (options.async) __webpack_require__(110);
+		if (options.dispose) __webpack_require__(113);
+		if (options.maxAge) __webpack_require__(114);
+		if (options.max) __webpack_require__(117);
+		if (options.refCounter) __webpack_require__(119);
+
+		return plain(fn, options);
+	};
+
+
+/***/ },
+/* 60 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var forEach = Array.prototype.forEach, create = Object.create;
+
+	var process = function (src, obj) {
+		var key;
+		for (key in src) obj[key] = src[key];
+	};
+
+	module.exports = function (options/*, …options*/) {
+		var result = create(null);
+		forEach.call(arguments, function (options) {
+			if (options == null) return;
+			process(Object(options), result);
+		});
+		return result;
+	};
+
+
+/***/ },
+/* 61 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toPosInt = __webpack_require__(62);
+
+	module.exports = function (optsLength, fnLength, isAsync) {
+		var length;
+		if (isNaN(optsLength)) {
+			length = fnLength;
+			if (!(length >= 0)) return 1;
+			if (isAsync && length) return length - 1;
+			return length;
+		}
+		if (optsLength === false) return false;
+		return toPosInt(optsLength);
+	};
+
+
+/***/ },
+/* 62 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toInteger = __webpack_require__(63)
+
+	  , max = Math.max;
+
+	module.exports = function (value) { return max(0, toInteger(value)); };
+
+
+/***/ },
+/* 63 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var sign = __webpack_require__(64)
+
+	  , abs = Math.abs, floor = Math.floor;
+
+	module.exports = function (value) {
+		if (isNaN(value)) return 0;
+		value = Number(value);
+		if ((value === 0) || !isFinite(value)) return value;
+		return sign(value) * floor(abs(value));
+	};
+
+
+/***/ },
+/* 64 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(65)()
+		? Math.sign
+		: __webpack_require__(66);
+
+
+/***/ },
+/* 65 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {
+		var sign = Math.sign;
+		if (typeof sign !== 'function') return false;
+		return ((sign(10) === 1) && (sign(-20) === -1));
+	};
+
+
+/***/ },
+/* 66 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (value) {
+		value = Number(value);
+		if (isNaN(value) || (value === 0)) return value;
+		return (value > 0) ? 1 : -1;
+	};
+
+
+/***/ },
+/* 67 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var callable      = __webpack_require__(68)
+	  , forEach       = __webpack_require__(69)
+	  , extensions    = __webpack_require__(72)
+	  , configure     = __webpack_require__(73)
+	  , resolveLength = __webpack_require__(61)
+
+	  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	module.exports = function self(fn/*, options */) {
+		var options, length, conf;
+
+		callable(fn);
+		options = Object(arguments[1]);
+
+		// Do not memoize already memoized function
+		if (hasOwnProperty.call(fn, '__memoized__') && !options.force) return fn;
+
+		// Resolve length;
+		length = resolveLength(options.length, fn.length, options.async && extensions.async);
+
+		// Configure cache map
+		conf = configure(fn, length, options);
+
+		// Bind eventual extensions
+		forEach(extensions, function (fn, name) {
+			if (options[name]) fn(options[name], conf, options);
+		});
+
+		if (self.__profiler__) self.__profiler__(conf);
+
+		conf.updateEnv();
+		return conf.memoized;
+	};
+
+
+/***/ },
+/* 68 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (fn) {
+		if (typeof fn !== 'function') throw new TypeError(fn + " is not a function");
+		return fn;
+	};
+
+
+/***/ },
+/* 69 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(70)('forEach');
+
+
+/***/ },
+/* 70 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Internal method, used by iteration functions.
+	// Calls a function for each key-value pair found in object
+	// Optionally takes compareFn to iterate object in specific order
+
+	'use strict';
+
+	var callable = __webpack_require__(68)
+	  , value    = __webpack_require__(71)
+
+	  , bind = Function.prototype.bind, call = Function.prototype.call, keys = Object.keys
+	  , propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	module.exports = function (method, defVal) {
+		return function (obj, cb/*, thisArg, compareFn*/) {
+			var list, thisArg = arguments[2], compareFn = arguments[3];
+			obj = Object(value(obj));
+			callable(cb);
+
+			list = keys(obj);
+			if (compareFn) {
+				list.sort((typeof compareFn === 'function') ? bind.call(compareFn, obj) : undefined);
+			}
+			if (typeof method !== 'function') method = list[method];
+			return call.call(method, list, function (key, index) {
+				if (!propertyIsEnumerable.call(obj, key)) return defVal;
+				return call.call(cb, thisArg, obj[key], key, obj, index);
+			});
+		};
+	};
+
+
+/***/ },
+/* 71 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (value) {
+		if (value == null) throw new TypeError("Cannot use null or undefined");
+		return value;
+	};
+
+
+/***/ },
+/* 72 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+
+/***/ },
+/* 73 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var customError      = __webpack_require__(74)
+	  , defineLength     = __webpack_require__(81)
+	  , d                = __webpack_require__(83)
+	  , ee               = __webpack_require__(88).methods
+	  , resolveResolve   = __webpack_require__(89)
+	  , resolveNormalize = __webpack_require__(103)
+
+	  , apply = Function.prototype.apply, call = Function.prototype.call
+	  , create = Object.create, hasOwnProperty = Object.prototype.hasOwnProperty
+	  , defineProperties = Object.defineProperties
+	  , on = ee.on, emit = ee.emit;
+
+	module.exports = function (original, length, options) {
+		var cache = create(null), conf, memLength, get, set, del, clear, extDel, normalizer
+		  , getListeners, setListeners, deleteListeners, memoized, resolve;
+		if (length !== false) memLength = length;
+		else if (isNaN(original.length)) memLength = 1;
+		else memLength = original.length;
+
+		if (options.normalizer) {
+			normalizer = resolveNormalize(options.normalizer);
+			get = normalizer.get;
+			set = normalizer.set;
+			del = normalizer.delete;
+			clear = normalizer.clear;
+		}
+		if (options.resolvers != null) resolve = resolveResolve(options.resolvers);
+
+		if (get) {
+			memoized = defineLength(function (arg) {
+				var id, result, args = arguments;
+				if (resolve) args = resolve(args);
+				id = get(args);
+				if (id !== null) {
+					if (hasOwnProperty.call(cache, id)) {
+						if (getListeners) conf.emit('get', id, args, this);
+						return cache[id];
+					}
+				}
+				if (args.length === 1) result = call.call(original, this, args[0]);
+				else result = apply.call(original, this, args);
+				if (id === null) {
+					id = get(args);
+					if (id !== null) throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+					id = set(args);
+				} else if (hasOwnProperty.call(cache, id)) {
+					throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+				}
+				cache[id] = result;
+				if (setListeners) conf.emit('set', id);
+				return result;
+			}, memLength);
+		} else if (length === 0) {
+			memoized = function () {
+				var result;
+				if (hasOwnProperty.call(cache, 'data')) {
+					if (getListeners) conf.emit('get', 'data', arguments, this);
+					return cache.data;
+				}
+				if (!arguments.length) result = call.call(original, this);
+				else result = apply.call(original, this, arguments);
+				if (hasOwnProperty.call(cache, 'data')) {
+					throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+				}
+				cache.data = result;
+				if (setListeners) conf.emit('set', 'data');
+				return result;
+			};
+		} else {
+			memoized = function (arg) {
+				var result, args = arguments, id;
+				if (resolve) args = resolve(arguments);
+				id = String(args[0]);
+				if (hasOwnProperty.call(cache, id)) {
+					if (getListeners) conf.emit('get', id, args, this);
+					return cache[id];
+				}
+				if (args.length === 1) result = call.call(original, this, args[0]);
+				else result = apply.call(original, this, args);
+				if (hasOwnProperty.call(cache, id)) {
+					throw customError("Circular invocation", 'CIRCULAR_INVOCATION');
+				}
+				cache[id] = result;
+				if (setListeners) conf.emit('set', id);
+				return result;
+			};
+		}
+		conf = {
+			original: original,
+			memoized: memoized,
+			get: function (args) {
+				if (resolve) args = resolve(args);
+				if (get) return get(args);
+				return String(args[0]);
+			},
+			has: function (id) { return hasOwnProperty.call(cache, id); },
+			delete: function (id) {
+				var result;
+				if (!hasOwnProperty.call(cache, id)) return;
+				if (del) del(id);
+				result = cache[id];
+				delete cache[id];
+				if (deleteListeners) conf.emit('delete', id, result);
+			},
+			clear: function () {
+				var oldCache = cache;
+				if (clear) clear();
+				cache = create(null);
+				conf.emit('clear', oldCache);
+			},
+			on: function (type, listener) {
+				if (type === 'get') getListeners = true;
+				else if (type === 'set') setListeners = true;
+				else if (type === 'delete') deleteListeners = true;
+				return on.call(this, type, listener);
+			},
+			emit: emit,
+			updateEnv: function () { original = conf.original; }
+		};
+		if (get) {
+			extDel = defineLength(function (arg) {
+				var id, args = arguments;
+				if (resolve) args = resolve(args);
+				id = get(args);
+				if (id === null) return;
+				conf.delete(id);
+			}, memLength);
+		} else if (length === 0) {
+			extDel = function () { return conf.delete('data'); };
+		} else {
+			extDel = function (arg) {
+				if (resolve) arg = resolve(arguments)[0];
+				return conf.delete(arg);
+			};
+		}
+		defineProperties(memoized, {
+			__memoized__: d(true),
+			delete: d(extDel),
+			clear: d(conf.clear)
+		});
+		return conf;
+	};
+
+
+/***/ },
+/* 74 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var assign = __webpack_require__(75)
+
+	  , captureStackTrace = Error.captureStackTrace;
+
+	exports = module.exports = function (message/*, code, ext*/) {
+		var err = new Error(), code = arguments[1], ext = arguments[2];
+		if (ext == null) {
+			if (code && (typeof code === 'object')) {
+				ext = code;
+				code = null;
+			}
+		}
+		if (ext != null) assign(err, ext);
+		err.message = String(message);
+		if (code != null) err.code = String(code);
+		if (captureStackTrace) captureStackTrace(err, exports);
+		return err;
+	};
+
+
+/***/ },
+/* 75 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(76)()
+		? Object.assign
+		: __webpack_require__(77);
+
+
+/***/ },
+/* 76 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {
+		var assign = Object.assign, obj;
+		if (typeof assign !== 'function') return false;
+		obj = { foo: 'raz' };
+		assign(obj, { bar: 'dwa' }, { trzy: 'trzy' });
+		return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy';
+	};
+
+
+/***/ },
+/* 77 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var keys  = __webpack_require__(78)
+	  , value = __webpack_require__(71)
+
+	  , max = Math.max;
+
+	module.exports = function (dest, src/*, …srcn*/) {
+		var error, i, l = max(arguments.length, 2), assign;
+		dest = Object(value(dest));
+		assign = function (key) {
+			try { dest[key] = src[key]; } catch (e) {
+				if (!error) error = e;
+			}
+		};
+		for (i = 1; i < l; ++i) {
+			src = arguments[i];
+			keys(src).forEach(assign);
+		}
+		if (error !== undefined) throw error;
+		return dest;
+	};
+
+
+/***/ },
+/* 78 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(79)()
+		? Object.keys
+		: __webpack_require__(80);
+
+
+/***/ },
+/* 79 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {
+		try {
+			Object.keys('primitive');
+			return true;
+		} catch (e) { return false; }
+	};
+
+
+/***/ },
+/* 80 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var keys = Object.keys;
+
+	module.exports = function (object) {
+		return keys(object == null ? object : Object(object));
+	};
+
+
+/***/ },
+/* 81 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toPosInt = __webpack_require__(62)
+
+	  , test = function (a, b) {}, desc, defineProperty
+	  , generate, mixin;
+
+	try {
+		Object.defineProperty(test, 'length', { configurable: true, writable: false,
+			enumerable: false, value: 1 });
+	} catch (ignore) {}
+
+	if (test.length === 1) {
+		// ES6
+		desc = { configurable: true, writable: false, enumerable: false };
+		defineProperty = Object.defineProperty;
+		module.exports = function (fn, length) {
+			length = toPosInt(length);
+			if (fn.length === length) return fn;
+			desc.value = length;
+			return defineProperty(fn, 'length', desc);
+		};
+	} else {
+		mixin = __webpack_require__(82);
+		generate = (function () {
+			var cache = [];
+			return function (l) {
+				var args, i = 0;
+				if (cache[l]) return cache[l];
+				args = [];
+				while (l--) args.push('a' + (++i).toString(36));
+				return new Function('fn', 'return function (' + args.join(', ') +
+					') { return fn.apply(this, arguments); };');
+			};
+		}());
+		module.exports = function (src, length) {
+			var target;
+			length = toPosInt(length);
+			if (src.length === length) return src;
+			target = generate(length)(src);
+			try { mixin(target, src); } catch (ignore) {}
+			return target;
+		};
+	}
+
+
+/***/ },
+/* 82 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var value = __webpack_require__(71)
+
+	  , defineProperty = Object.defineProperty
+	  , getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+	  , getOwnPropertyNames = Object.getOwnPropertyNames;
+
+	module.exports = function (target, source) {
+		var error;
+		target = Object(value(target));
+		getOwnPropertyNames(Object(value(source))).forEach(function (name) {
+			try {
+				defineProperty(target, name, getOwnPropertyDescriptor(source, name));
+			} catch (e) { error = e; }
+		});
+		if (error !== undefined) throw error;
+		return target;
+	};
+
+
+/***/ },
+/* 83 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var assign        = __webpack_require__(75)
+	  , normalizeOpts = __webpack_require__(60)
+	  , isCallable    = __webpack_require__(84)
+	  , contains      = __webpack_require__(85)
+
+	  , d;
+
+	d = module.exports = function (dscr, value/*, options*/) {
+		var c, e, w, options, desc;
+		if ((arguments.length < 2) || (typeof dscr !== 'string')) {
+			options = value;
+			value = dscr;
+			dscr = null;
+		} else {
+			options = arguments[2];
+		}
+		if (dscr == null) {
+			c = w = true;
+			e = false;
+		} else {
+			c = contains.call(dscr, 'c');
+			e = contains.call(dscr, 'e');
+			w = contains.call(dscr, 'w');
+		}
+
+		desc = { value: value, configurable: c, enumerable: e, writable: w };
+		return !options ? desc : assign(normalizeOpts(options), desc);
+	};
+
+	d.gs = function (dscr, get, set/*, options*/) {
+		var c, e, options, desc;
+		if (typeof dscr !== 'string') {
+			options = set;
+			set = get;
+			get = dscr;
+			dscr = null;
+		} else {
+			options = arguments[3];
+		}
+		if (get == null) {
+			get = undefined;
+		} else if (!isCallable(get)) {
+			options = get;
+			get = set = undefined;
+		} else if (set == null) {
+			set = undefined;
+		} else if (!isCallable(set)) {
+			options = set;
+			set = undefined;
+		}
+		if (dscr == null) {
+			c = true;
+			e = false;
+		} else {
+			c = contains.call(dscr, 'c');
+			e = contains.call(dscr, 'e');
+		}
+
+		desc = { get: get, set: set, configurable: c, enumerable: e };
+		return !options ? desc : assign(normalizeOpts(options), desc);
+	};
+
+
+/***/ },
+/* 84 */
+/***/ function(module, exports) {
+
+	// Deprecated
+
+	'use strict';
+
+	module.exports = function (obj) { return typeof obj === 'function'; };
+
+
+/***/ },
+/* 85 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(86)()
+		? String.prototype.contains
+		: __webpack_require__(87);
+
+
+/***/ },
+/* 86 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var str = 'razdwatrzy';
+
+	module.exports = function () {
+		if (typeof str.contains !== 'function') return false;
+		return ((str.contains('dwa') === true) && (str.contains('foo') === false));
+	};
+
+
+/***/ },
+/* 87 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var indexOf = String.prototype.indexOf;
+
+	module.exports = function (searchString/*, position*/) {
+		return indexOf.call(this, searchString, arguments[1]) > -1;
+	};
+
+
+/***/ },
+/* 88 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var d        = __webpack_require__(83)
+	  , callable = __webpack_require__(68)
+
+	  , apply = Function.prototype.apply, call = Function.prototype.call
+	  , create = Object.create, defineProperty = Object.defineProperty
+	  , defineProperties = Object.defineProperties
+	  , hasOwnProperty = Object.prototype.hasOwnProperty
+	  , descriptor = { configurable: true, enumerable: false, writable: true }
+
+	  , on, once, off, emit, methods, descriptors, base;
+
+	on = function (type, listener) {
+		var data;
+
+		callable(listener);
+
+		if (!hasOwnProperty.call(this, '__ee__')) {
+			data = descriptor.value = create(null);
+			defineProperty(this, '__ee__', descriptor);
+			descriptor.value = null;
+		} else {
+			data = this.__ee__;
+		}
+		if (!data[type]) data[type] = listener;
+		else if (typeof data[type] === 'object') data[type].push(listener);
+		else data[type] = [data[type], listener];
+
+		return this;
+	};
+
+	once = function (type, listener) {
+		var once, self;
+
+		callable(listener);
+		self = this;
+		on.call(this, type, once = function () {
+			off.call(self, type, once);
+			apply.call(listener, this, arguments);
+		});
+
+		once.__eeOnceListener__ = listener;
+		return this;
+	};
+
+	off = function (type, listener) {
+		var data, listeners, candidate, i;
+
+		callable(listener);
+
+		if (!hasOwnProperty.call(this, '__ee__')) return this;
+		data = this.__ee__;
+		if (!data[type]) return this;
+		listeners = data[type];
+
+		if (typeof listeners === 'object') {
+			for (i = 0; (candidate = listeners[i]); ++i) {
+				if ((candidate === listener) ||
+						(candidate.__eeOnceListener__ === listener)) {
+					if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
+					else listeners.splice(i, 1);
+				}
+			}
+		} else {
+			if ((listeners === listener) ||
+					(listeners.__eeOnceListener__ === listener)) {
+				delete data[type];
+			}
+		}
+
+		return this;
+	};
+
+	emit = function (type) {
+		var i, l, listener, listeners, args;
+
+		if (!hasOwnProperty.call(this, '__ee__')) return;
+		listeners = this.__ee__[type];
+		if (!listeners) return;
+
+		if (typeof listeners === 'object') {
+			l = arguments.length;
+			args = new Array(l - 1);
+			for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+
+			listeners = listeners.slice();
+			for (i = 0; (listener = listeners[i]); ++i) {
+				apply.call(listener, this, args);
+			}
+		} else {
+			switch (arguments.length) {
+			case 1:
+				call.call(listeners, this);
+				break;
+			case 2:
+				call.call(listeners, this, arguments[1]);
+				break;
+			case 3:
+				call.call(listeners, this, arguments[1], arguments[2]);
+				break;
+			default:
+				l = arguments.length;
+				args = new Array(l - 1);
+				for (i = 1; i < l; ++i) {
+					args[i - 1] = arguments[i];
+				}
+				apply.call(listeners, this, args);
+			}
+		}
+	};
+
+	methods = {
+		on: on,
+		once: once,
+		off: off,
+		emit: emit
+	};
+
+	descriptors = {
+		on: d(on),
+		once: d(once),
+		off: d(off),
+		emit: d(emit)
+	};
+
+	base = defineProperties({}, descriptors);
+
+	module.exports = exports = function (o) {
+		return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
+	};
+	exports.methods = methods;
+
+
+/***/ },
+/* 89 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toArray  = __webpack_require__(90)
+	  , callable = __webpack_require__(68)
+
+	  , slice = Array.prototype.slice
+	  , resolveArgs;
+
+	resolveArgs = function (args) {
+		return this.map(function (r, i) {
+			return r ? r(args[i]) : args[i];
+		}).concat(slice.call(args, this.length));
+	};
+
+	module.exports = function (resolvers) {
+		resolvers = toArray(resolvers);
+		resolvers.forEach(function (r) {
+			if (r != null) callable(r);
+		});
+		return resolveArgs.bind(resolvers);
+	};
+
+
+/***/ },
+/* 90 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var from = __webpack_require__(91)
+
+	  , isArray = Array.isArray;
+
+	module.exports = function (arrayLike) {
+		return isArray(arrayLike) ? arrayLike : from(arrayLike);
+	};
+
+
+/***/ },
+/* 91 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(92)()
+		? Array.from
+		: __webpack_require__(93);
+
+
+/***/ },
+/* 92 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {
+		var from = Array.from, arr, result;
+		if (typeof from !== 'function') return false;
+		arr = ['raz', 'dwa'];
+		result = from(arr);
+		return Boolean(result && (result !== arr) && (result[1] === 'dwa'));
+	};
+
+
+/***/ },
+/* 93 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var iteratorSymbol = __webpack_require__(94).iterator
+	  , isArguments    = __webpack_require__(99)
+	  , isFunction     = __webpack_require__(100)
+	  , toPosInt       = __webpack_require__(62)
+	  , callable       = __webpack_require__(68)
+	  , validValue     = __webpack_require__(71)
+	  , isString       = __webpack_require__(102)
+
+	  , isArray = Array.isArray, call = Function.prototype.call
+	  , desc = { configurable: true, enumerable: true, writable: true, value: null }
+	  , defineProperty = Object.defineProperty;
+
+	module.exports = function (arrayLike/*, mapFn, thisArg*/) {
+		var mapFn = arguments[1], thisArg = arguments[2], Constructor, i, j, arr, l, code, iterator
+		  , result, getIterator, value;
+
+		arrayLike = Object(validValue(arrayLike));
+
+		if (mapFn != null) callable(mapFn);
+		if (!this || (this === Array) || !isFunction(this)) {
+			// Result: Plain array
+			if (!mapFn) {
+				if (isArguments(arrayLike)) {
+					// Source: Arguments
+					l = arrayLike.length;
+					if (l !== 1) return Array.apply(null, arrayLike);
+					arr = new Array(1);
+					arr[0] = arrayLike[0];
+					return arr;
+				}
+				if (isArray(arrayLike)) {
+					// Source: Array
+					arr = new Array(l = arrayLike.length);
+					for (i = 0; i < l; ++i) arr[i] = arrayLike[i];
+					return arr;
+				}
+			}
+			arr = [];
+		} else {
+			// Result: Non plain array
+			Constructor = this;
+		}
+
+		if (!isArray(arrayLike)) {
+			if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
+				// Source: Iterator
+				iterator = callable(getIterator).call(arrayLike);
+				if (Constructor) arr = new Constructor();
+				result = iterator.next();
+				i = 0;
+				while (!result.done) {
+					value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
+					if (!Constructor) {
+						arr[i] = value;
+					} else {
+						desc.value = value;
+						defineProperty(arr, i, desc);
+					}
+					result = iterator.next();
+					++i;
+				}
+				l = i;
+			} else if (isString(arrayLike)) {
+				// Source: String
+				l = arrayLike.length;
+				if (Constructor) arr = new Constructor();
+				for (i = 0, j = 0; i < l; ++i) {
+					value = arrayLike[i];
+					if ((i + 1) < l) {
+						code = value.charCodeAt(0);
+						if ((code >= 0xD800) && (code <= 0xDBFF)) value += arrayLike[++i];
+					}
+					value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+					if (!Constructor) {
+						arr[j] = value;
+					} else {
+						desc.value = value;
+						defineProperty(arr, j, desc);
+					}
+					++j;
+				}
+				l = j;
+			}
+		}
+		if (l === undefined) {
+			// Source: array or array-like
+			l = toPosInt(arrayLike.length);
+			if (Constructor) arr = new Constructor(l);
+			for (i = 0; i < l; ++i) {
+				value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
+				if (!Constructor) {
+					arr[i] = value;
+				} else {
+					desc.value = value;
+					defineProperty(arr, i, desc);
+				}
+			}
+		}
+		if (Constructor) {
+			desc.value = null;
+			arr.length = l;
+		}
+		return arr;
+	};
+
+
+/***/ },
+/* 94 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(95)() ? Symbol : __webpack_require__(96);
+
+
+/***/ },
+/* 95 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {
+		var symbol;
+		if (typeof Symbol !== 'function') return false;
+		symbol = Symbol('test symbol');
+		try { String(symbol); } catch (e) { return false; }
+		if (typeof Symbol.iterator === 'symbol') return true;
+
+		// Return 'true' for polyfills
+		if (typeof Symbol.isConcatSpreadable !== 'object') return false;
+		if (typeof Symbol.iterator !== 'object') return false;
+		if (typeof Symbol.toPrimitive !== 'object') return false;
+		if (typeof Symbol.toStringTag !== 'object') return false;
+		if (typeof Symbol.unscopables !== 'object') return false;
+
+		return true;
+	};
+
+
+/***/ },
+/* 96 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// ES2015 Symbol polyfill for environments that do not support it (or partially support it_
+
+	'use strict';
+
+	var d              = __webpack_require__(83)
+	  , validateSymbol = __webpack_require__(97)
+
+	  , create = Object.create, defineProperties = Object.defineProperties
+	  , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+	  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null);
+
+	if (typeof Symbol === 'function') NativeSymbol = Symbol;
+
+	var generateName = (function () {
+		var created = create(null);
+		return function (desc) {
+			var postfix = 0, name, ie11BugWorkaround;
+			while (created[desc + (postfix || '')]) ++postfix;
+			desc += (postfix || '');
+			created[desc] = true;
+			name = '@@' + desc;
+			defineProperty(objPrototype, name, d.gs(null, function (value) {
+				// For IE11 issue see:
+				// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+				//    ie11-broken-getters-on-dom-objects
+				// https://github.com/medikoo/es6-symbol/issues/12
+				if (ie11BugWorkaround) return;
+				ie11BugWorkaround = true;
+				defineProperty(this, name, d(value));
+				ie11BugWorkaround = false;
+			}));
+			return name;
+		};
+	}());
+
+	// Internal constructor (not one exposed) for creating Symbol instances.
+	// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+	HiddenSymbol = function Symbol(description) {
+		if (this instanceof HiddenSymbol) throw new TypeError('TypeError: Symbol is not a constructor');
+		return SymbolPolyfill(description);
+	};
+
+	// Exposed `Symbol` constructor
+	// (returns instances of HiddenSymbol)
+	module.exports = SymbolPolyfill = function Symbol(description) {
+		var symbol;
+		if (this instanceof Symbol) throw new TypeError('TypeError: Symbol is not a constructor');
+		symbol = create(HiddenSymbol.prototype);
+		description = (description === undefined ? '' : String(description));
+		return defineProperties(symbol, {
+			__description__: d('', description),
+			__name__: d('', generateName(description))
+		});
+	};
+	defineProperties(SymbolPolyfill, {
+		for: d(function (key) {
+			if (globalSymbols[key]) return globalSymbols[key];
+			return (globalSymbols[key] = SymbolPolyfill(String(key)));
+		}),
+		keyFor: d(function (s) {
+			var key;
+			validateSymbol(s);
+			for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+		}),
+
+		// If there's native implementation of given symbol, let's fallback to it
+		// to ensure proper interoperability with other native functions e.g. Array.from
+		hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+		isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+			SymbolPolyfill('isConcatSpreadable')),
+		iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+		match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+		replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+		search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+		species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+		split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+		toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+		toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+		unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
+	});
+
+	// Internal tweaks for real symbol producer
+	defineProperties(HiddenSymbol.prototype, {
+		constructor: d(SymbolPolyfill),
+		toString: d('', function () { return this.__name__; })
+	});
+
+	// Proper implementation of methods exposed on Symbol.prototype
+	// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+	defineProperties(SymbolPolyfill.prototype, {
+		toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+		valueOf: d(function () { return validateSymbol(this); })
+	});
+	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('',
+		function () { return validateSymbol(this); }));
+	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));
+
+	// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+		d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
+
+	// Note: It's important to define `toPrimitive` as last one, as some implementations
+	// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+	// And that may invoke error in definition flow:
+	// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+		d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+
+
+/***/ },
+/* 97 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var isSymbol = __webpack_require__(98);
+
+	module.exports = function (value) {
+		if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+		return value;
+	};
+
+
+/***/ },
+/* 98 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (x) {
+		return (x && ((typeof x === 'symbol') || (x['@@toStringTag'] === 'Symbol'))) || false;
+	};
+
+
+/***/ },
+/* 99 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var toString = Object.prototype.toString
+
+	  , id = toString.call((function () { return arguments; }()));
+
+	module.exports = function (x) { return (toString.call(x) === id); };
+
+
+/***/ },
+/* 100 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toString = Object.prototype.toString
+
+	  , id = toString.call(__webpack_require__(101));
+
+	module.exports = function (f) {
+		return (typeof f === "function") && (toString.call(f) === id);
+	};
+
+
+/***/ },
+/* 101 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function () {};
+
+
+/***/ },
+/* 102 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	var toString = Object.prototype.toString
+
+	  , id = toString.call('');
+
+	module.exports = function (x) {
+		return (typeof x === 'string') || (x && (typeof x === 'object') &&
+			((x instanceof String) || (toString.call(x) === id))) || false;
+	};
+
+
+/***/ },
+/* 103 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var callable = __webpack_require__(68);
+
+	module.exports = function (userNormalizer) {
+		var normalizer;
+		if (typeof userNormalizer === 'function') return { set: userNormalizer, get: userNormalizer };
+		normalizer = { get: callable(userNormalizer.get) };
+		if (userNormalizer.set !== undefined) {
+			normalizer.set = callable(userNormalizer.set);
+			normalizer.delete = callable(userNormalizer.delete);
+			normalizer.clear = callable(userNormalizer.clear);
+			return normalizer;
+		}
+		normalizer.set = normalizer.get;
+		return normalizer;
+	};
+
+
+/***/ },
+/* 104 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (args) {
+		var id, i, length = args.length;
+		if (!length) return '\u0002';
+		id = String(args[i = 0]);
+		while (--length) id += '\u0001' + args[++i];
+		return id;
+	};
+
+
+/***/ },
+/* 105 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = function (length) {
+		if (!length) {
+			return function () { return ''; };
+		}
+		return function (args) {
+			var id = String(args[0]), i = 0, l = length;
+			while (--l) { id += '\u0001' + args[++i]; }
+			return id;
+		};
+	};
+
+
+/***/ },
+/* 106 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var indexOf = __webpack_require__(107)
+	  , create = Object.create;
+
+	module.exports = function () {
+		var lastId = 0, map = [], cache = create(null);
+		return {
+			get: function (args) {
+				var index = 0, set = map, i, length = args.length;
+				if (length === 0) return set[length] || null;
+				if ((set = set[length])) {
+					while (index < (length - 1)) {
+						i = indexOf.call(set[0], args[index]);
+						if (i === -1) return null;
+						set = set[1][i];
+						++index;
+					}
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) return null;
+					return set[1][i] || null;
+				}
+				return null;
+			},
+			set: function (args) {
+				var index = 0, set = map, i, length = args.length;
+				if (length === 0) {
+					set[length] = ++lastId;
+				} else {
+					if (!set[length]) {
+						set[length] = [[], []];
+					}
+					set = set[length];
+					while (index < (length - 1)) {
+						i = indexOf.call(set[0], args[index]);
+						if (i === -1) {
+							i = set[0].push(args[index]) - 1;
+							set[1].push([[], []]);
+						}
+						set = set[1][i];
+						++index;
+					}
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						i = set[0].push(args[index]) - 1;
+					}
+					set[1][i] = ++lastId;
+				}
+				cache[lastId] = args;
+				return lastId;
+			},
+			delete: function (id) {
+				var index = 0, set = map, i, args = cache[id], length = args.length
+				  , path = [];
+				if (length === 0) {
+					delete set[length];
+				} else if ((set = set[length])) {
+					while (index < (length - 1)) {
+						i = indexOf.call(set[0], args[index]);
+						if (i === -1) {
+							return;
+						}
+						path.push(set, i);
+						set = set[1][i];
+						++index;
+					}
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						return;
+					}
+					id = set[1][i];
+					set[0].splice(i, 1);
+					set[1].splice(i, 1);
+					while (!set[0].length && path.length) {
+						i = path.pop();
+						set = path.pop();
+						set[0].splice(i, 1);
+						set[1].splice(i, 1);
+					}
+				}
+				delete cache[id];
+			},
+			clear: function () {
+				map = [];
+				cache = create(null);
+			}
+		};
+	};
+
+
+/***/ },
+/* 107 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toPosInt = __webpack_require__(62)
+	  , value    = __webpack_require__(71)
+
+	  , indexOf = Array.prototype.indexOf
+	  , hasOwnProperty = Object.prototype.hasOwnProperty
+	  , abs = Math.abs, floor = Math.floor;
+
+	module.exports = function (searchElement/*, fromIndex*/) {
+		var i, l, fromIndex, val;
+		if (searchElement === searchElement) { //jslint: ignore
+			return indexOf.apply(this, arguments);
+		}
+
+		l = toPosInt(value(this).length);
+		fromIndex = arguments[1];
+		if (isNaN(fromIndex)) fromIndex = 0;
+		else if (fromIndex >= 0) fromIndex = floor(fromIndex);
+		else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));
+
+		for (i = fromIndex; i < l; ++i) {
+			if (hasOwnProperty.call(this, i)) {
+				val = this[i];
+				if (val !== val) return i; //jslint: ignore
+			}
+		}
+		return -1;
+	};
+
+
+/***/ },
+/* 108 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var indexOf = __webpack_require__(107);
+
+	module.exports = function () {
+		var lastId = 0, argsMap = [], cache = [];
+		return {
+			get: function (args) {
+				var index = indexOf.call(argsMap, args[0]);
+				return (index === -1) ? null : cache[index];
+			},
+			set: function (args) {
+				argsMap.push(args[0]);
+				cache.push(++lastId);
+				return lastId;
+			},
+			delete: function (id) {
+				var index = indexOf.call(cache, id);
+				if (index !== -1) {
+					argsMap.splice(index, 1);
+					cache.splice(index, 1);
+				}
+			},
+			clear: function () {
+				argsMap = [];
+				cache = [];
+			}
+		};
+	};
+
+
+/***/ },
+/* 109 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var indexOf = __webpack_require__(107)
+	  , create = Object.create;
+
+	module.exports = function (length) {
+		var lastId = 0, map = [[], []], cache = create(null);
+		return {
+			get: function (args) {
+				var index = 0, set = map, i;
+				while (index < (length - 1)) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) return null;
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) return null;
+				return set[1][i] || null;
+			},
+			set: function (args) {
+				var index = 0, set = map, i;
+				while (index < (length - 1)) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						i = set[0].push(args[index]) - 1;
+						set[1].push([[], []]);
+					}
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					i = set[0].push(args[index]) - 1;
+				}
+				set[1][i] = ++lastId;
+				cache[lastId] = args;
+				return lastId;
+			},
+			delete: function (id) {
+				var index = 0, set = map, i, path = [], args = cache[id];
+				while (index < (length - 1)) {
+					i = indexOf.call(set[0], args[index]);
+					if (i === -1) {
+						return;
+					}
+					path.push(set, i);
+					set = set[1][i];
+					++index;
+				}
+				i = indexOf.call(set[0], args[index]);
+				if (i === -1) {
+					return;
+				}
+				id = set[1][i];
+				set[0].splice(i, 1);
+				set[1].splice(i, 1);
+				while (!set[0].length && path.length) {
+					i = path.pop();
+					set = path.pop();
+					set[0].splice(i, 1);
+					set[1].splice(i, 1);
+				}
+				delete cache[id];
+			},
+			clear: function () {
+				map = [[], []];
+				cache = create(null);
+			}
+		};
+	};
+
+
+/***/ },
+/* 110 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Support for asynchronous functions
+
+	'use strict';
+
+	var aFrom        = __webpack_require__(91)
+	  , mixin        = __webpack_require__(82)
+	  , defineLength = __webpack_require__(81)
+	  , nextTick     = __webpack_require__(111)
+
+	  , slice = Array.prototype.slice
+	  , apply = Function.prototype.apply, create = Object.create
+	  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	__webpack_require__(72).async = function (tbi, conf) {
+		var waiting = create(null), cache = create(null)
+		  , base = conf.memoized, original = conf.original
+		  , currentCallback, currentContext, currentArgs;
+
+		// Initial
+		conf.memoized = defineLength(function (arg) {
+			var args = arguments, last = args[args.length - 1];
+			if (typeof last === 'function') {
+				currentCallback = last;
+				args = slice.call(args, 0, -1);
+			}
+			return base.apply(currentContext = this, currentArgs = args);
+		}, base);
+		try { mixin(conf.memoized, base); } catch (ignore) {}
+
+		// From cache (sync)
+		conf.on('get', function (id) {
+			var cb, context, args;
+			if (!currentCallback) return;
+
+			// Unresolved
+			if (waiting[id]) {
+				if (typeof waiting[id] === 'function') waiting[id] = [waiting[id], currentCallback];
+				else waiting[id].push(currentCallback);
+				currentCallback = null;
+				return;
+			}
+
+			// Resolved, assure next tick invocation
+			cb = currentCallback;
+			context = currentContext;
+			args = currentArgs;
+			currentCallback = currentContext = currentArgs = null;
+			nextTick(function () {
+				var data;
+				if (hasOwnProperty.call(cache, id)) {
+					data = cache[id];
+					conf.emit('getasync', id, args, context);
+					apply.call(cb, data.context, data.args);
+				} else {
+					// Purged in a meantime, we shouldn't rely on cached value, recall
+					currentCallback = cb;
+					currentContext = context;
+					currentArgs = args;
+					base.apply(context, args);
+				}
+			});
+		});
+
+		// Not from cache
+		conf.original = function () {
+			var args, cb, origCb, result;
+			if (!currentCallback) return apply.call(original, this, arguments);
+			args = aFrom(arguments);
+			cb = function self(err) {
+				var cb, args, id = self.id;
+				if (id == null) {
+					// Shouldn't happen, means async callback was called sync way
+					nextTick(apply.bind(self, this, arguments));
+					return;
+				}
+				delete self.id;
+				cb = waiting[id];
+				delete waiting[id];
+				if (!cb) {
+					// Already processed,
+					// outcome of race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+					return;
+				}
+				args = aFrom(arguments);
+				if (conf.has(id)) {
+					if (err) {
+						conf.delete(id);
+					} else {
+						cache[id] = { context: this, args: args };
+						conf.emit('setasync', id, (typeof cb === 'function') ? 1 : cb.length);
+					}
+				}
+				if (typeof cb === 'function') {
+					result = apply.call(cb, this, args);
+				} else {
+					cb.forEach(function (cb) { result = apply.call(cb, this, args); }, this);
+				}
+				return result;
+			};
+			origCb = currentCallback;
+			currentCallback = currentContext = currentArgs = null;
+			args.push(cb);
+			result = apply.call(original, this, args);
+			cb.cb = origCb;
+			currentCallback = cb;
+			return result;
+		};
+
+		// After not from cache call
+		conf.on('set', function (id) {
+			if (!currentCallback) {
+				conf.delete(id);
+				return;
+			}
+			if (waiting[id]) {
+				// Race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+				if (typeof waiting[id] === 'function') waiting[id] = [waiting[id], currentCallback.cb];
+				else waiting[id].push(currentCallback.cb);
+			} else {
+				waiting[id] = currentCallback.cb;
+			}
+			delete currentCallback.cb;
+			currentCallback.id = id;
+			currentCallback = null;
+		});
+
+		// On delete
+		conf.on('delete', function (id) {
+			var result;
+			// If false, we don't have value yet, so we assume that intention is not
+			// to memoize this call. After value is obtained we don't cache it but
+			// gracefully pass to callback
+			if (hasOwnProperty.call(waiting, id)) return;
+			if (!cache[id]) return;
+			result = cache[id];
+			delete cache[id];
+			conf.emit('deleteasync', id, result);
+		});
+
+		// On clear
+		conf.on('clear', function () {
+			var oldCache = cache;
+			cache = create(null);
+			conf.emit('clearasync', oldCache);
+		});
+	};
+
+
+/***/ },
+/* 111 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process, setImmediate) {'use strict';
+
+	var callable, byObserver;
+
+	callable = function (fn) {
+		if (typeof fn !== 'function') throw new TypeError(fn + " is not a function");
+		return fn;
+	};
+
+	byObserver = function (Observer) {
+		var node = document.createTextNode(''), queue, i = 0;
+		new Observer(function () {
+			var data;
+			if (!queue) return;
+			data = queue;
+			queue = null;
+			if (typeof data === 'function') {
+				data();
+				return;
+			}
+			data.forEach(function (fn) { fn(); });
+		}).observe(node, { characterData: true });
+		return function (fn) {
+			callable(fn);
+			if (queue) {
+				if (typeof queue === 'function') queue = [queue, fn];
+				else queue.push(fn);
+				return;
+			}
+			queue = fn;
+			node.data = (i = ++i % 2);
+		};
+	};
+
+	module.exports = (function () {
+		// Node.js
+		if ((typeof process !== 'undefined') && process &&
+				(typeof process.nextTick === 'function')) {
+			return process.nextTick;
+		}
+
+		// MutationObserver=
+		if ((typeof document === 'object') && document) {
+			if (typeof MutationObserver === 'function') {
+				return byObserver(MutationObserver);
+			}
+			if (typeof WebKitMutationObserver === 'function') {
+				return byObserver(WebKitMutationObserver);
+			}
+		}
+
+		// W3C Draft
+		// http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/setImmediate/Overview.html
+		if (typeof setImmediate === 'function') {
+			return function (cb) { setImmediate(callable(cb)); };
+		}
+
+		// Wide available standard
+		if (typeof setTimeout === 'function') {
+			return function (cb) { setTimeout(callable(cb), 0); };
+		}
+
+		return null;
+	}());
+
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(112).setImmediate))
+
+/***/ },
+/* 112 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(setImmediate, clearImmediate) {var nextTick = __webpack_require__(3).nextTick;
+	var apply = Function.prototype.apply;
+	var slice = Array.prototype.slice;
+	var immediateIds = {};
+	var nextImmediateId = 0;
+
+	// DOM APIs, for completeness
+
+	exports.setTimeout = function() {
+	  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+	};
+	exports.setInterval = function() {
+	  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+	};
+	exports.clearTimeout =
+	exports.clearInterval = function(timeout) { timeout.close(); };
+
+	function Timeout(id, clearFn) {
+	  this._id = id;
+	  this._clearFn = clearFn;
+	}
+	Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+	Timeout.prototype.close = function() {
+	  this._clearFn.call(window, this._id);
+	};
+
+	// Does not start the time, just sets up the members needed.
+	exports.enroll = function(item, msecs) {
+	  clearTimeout(item._idleTimeoutId);
+	  item._idleTimeout = msecs;
+	};
+
+	exports.unenroll = function(item) {
+	  clearTimeout(item._idleTimeoutId);
+	  item._idleTimeout = -1;
+	};
+
+	exports._unrefActive = exports.active = function(item) {
+	  clearTimeout(item._idleTimeoutId);
+
+	  var msecs = item._idleTimeout;
+	  if (msecs >= 0) {
+	    item._idleTimeoutId = setTimeout(function onTimeout() {
+	      if (item._onTimeout)
+	        item._onTimeout();
+	    }, msecs);
+	  }
+	};
+
+	// That's not how node.js implements it but the exposed api is the same.
+	exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
+	  var id = nextImmediateId++;
+	  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+	  immediateIds[id] = true;
+
+	  nextTick(function onNextTick() {
+	    if (immediateIds[id]) {
+	      // fn.call() is faster so we optimize for the common use-case
+	      // @see http://jsperf.com/call-apply-segu
+	      if (args) {
+	        fn.apply(null, args);
+	      } else {
+	        fn.call(null);
+	      }
+	      // Prevent ids from leaking
+	      exports.clearImmediate(id);
+	    }
+	  });
+
+	  return id;
+	};
+
+	exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
+	  delete immediateIds[id];
+	};
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(112).setImmediate, __webpack_require__(112).clearImmediate))
+
+/***/ },
+/* 113 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Call dispose callback on each cache purge
+
+	'use strict';
+
+	var callable   = __webpack_require__(68)
+	  , forEach    = __webpack_require__(69)
+	  , extensions = __webpack_require__(72)
+
+	  , slice = Array.prototype.slice, apply = Function.prototype.apply;
+
+	extensions.dispose = function (dispose, conf, options) {
+		var del;
+		callable(dispose);
+		if (options.async && extensions.async) {
+			conf.on('deleteasync', del = function (id, result) {
+				apply.call(dispose, null, slice.call(result.args, 1));
+			});
+			conf.on('clearasync', function (cache) {
+				forEach(cache, function (result, id) { del(id, result); });
+			});
+			return;
+		}
+		conf.on('delete', del = function (id, result) { dispose(result); });
+		conf.on('clear', function (cache) {
+			forEach(cache, function (result, id) { del(id, result); });
+		});
+	};
+
+
+/***/ },
+/* 114 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Timeout cached values
+
+	'use strict';
+
+	var aFrom      = __webpack_require__(91)
+	  , noop       = __webpack_require__(101)
+	  , forEach    = __webpack_require__(69)
+	  , timeout    = __webpack_require__(115)
+	  , extensions = __webpack_require__(72)
+
+	  , max = Math.max, min = Math.min, create = Object.create;
+
+	extensions.maxAge = function (maxAge, conf, options) {
+		var timeouts, postfix, preFetchAge, preFetchTimeouts;
+
+		maxAge = timeout(maxAge);
+		if (!maxAge) return;
+
+		timeouts = create(null);
+		postfix = (options.async && extensions.async) ? 'async' : '';
+		conf.on('set' + postfix, function (id) {
+			timeouts[id] = setTimeout(function () { conf.delete(id); }, maxAge);
+			if (!preFetchTimeouts) return;
+			if (preFetchTimeouts[id]) clearTimeout(preFetchTimeouts[id]);
+			preFetchTimeouts[id] = setTimeout(function () {
+				delete preFetchTimeouts[id];
+			}, preFetchAge);
+		});
+		conf.on('delete' + postfix, function (id) {
+			clearTimeout(timeouts[id]);
+			delete timeouts[id];
+			if (!preFetchTimeouts) return;
+			clearTimeout(preFetchTimeouts[id]);
+			delete preFetchTimeouts[id];
+		});
+
+		if (options.preFetch) {
+			if ((options.preFetch === true) || isNaN(options.preFetch)) {
+				preFetchAge = 0.333;
+			} else {
+				preFetchAge = max(min(Number(options.preFetch), 1), 0);
+			}
+			if (preFetchAge) {
+				preFetchTimeouts = {};
+				preFetchAge = (1 - preFetchAge) * maxAge;
+				conf.on('get' + postfix, function (id, args, context) {
+					if (!preFetchTimeouts[id]) {
+						preFetchTimeouts[id] =  setTimeout(function () {
+							delete preFetchTimeouts[id];
+							conf.delete(id);
+							if (options.async) {
+								args = aFrom(args);
+								args.push(noop);
+							}
+							conf.memoized.apply(context, args);
+						}, 0);
+					}
+				});
+			}
+		}
+
+		conf.on('clear' + postfix, function () {
+			forEach(timeouts, function (id) { clearTimeout(id); });
+			timeouts = {};
+			if (preFetchTimeouts) {
+				forEach(preFetchTimeouts, function (id) { clearTimeout(id); });
+				preFetchTimeouts = {};
+			}
+		});
+	};
+
+
+/***/ },
+/* 115 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toPosInt   = __webpack_require__(62)
+	  , maxTimeout = __webpack_require__(116);
+
+	module.exports = function (value) {
+		value = toPosInt(value);
+		if (value > maxTimeout) throw new TypeError(value + " exceeds maximum possible timeout");
+		return value;
+	};
+
+
+/***/ },
+/* 116 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	module.exports = 2147483647;
+
+
+/***/ },
+/* 117 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Limit cache size, LRU (least recently used) algorithm.
+
+	'use strict';
+
+	var toPosInteger = __webpack_require__(62)
+	  , lruQueue     = __webpack_require__(118)
+	  , extensions   = __webpack_require__(72);
+
+	extensions.max = function (max, conf, options) {
+		var postfix, queue, hit;
+
+		max = toPosInteger(max);
+		if (!max) return;
+
+		queue = lruQueue(max);
+		postfix = (options.async && extensions.async) ? 'async' : '';
+
+		conf.on('set' + postfix, hit = function (id) {
+			id = queue.hit(id);
+			if (id === undefined) return;
+			conf.delete(id);
+		});
+		conf.on('get' + postfix, hit);
+		conf.on('delete' + postfix, queue.delete);
+		conf.on('clear' + postfix, queue.clear);
+	};
+
+
+/***/ },
+/* 118 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var toPosInt = __webpack_require__(62)
+
+	  , create = Object.create, hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	module.exports = function (limit) {
+		var size = 0, base = 1, queue = create(null), map = create(null), index = 0, del;
+		limit = toPosInt(limit);
+		return {
+			hit: function (id) {
+				var oldIndex = map[id], nuIndex = ++index;
+				queue[nuIndex] = id;
+				map[id] = nuIndex;
+				if (!oldIndex) {
+					++size;
+					if (size <= limit) return;
+					id = queue[base];
+					del(id);
+					return id;
+				}
+				delete queue[oldIndex];
+				if (base !== oldIndex) return;
+				while (!hasOwnProperty.call(queue, ++base)) continue; //jslint: skip
+			},
+			delete: del = function (id) {
+				var oldIndex = map[id];
+				if (!oldIndex) return;
+				delete queue[oldIndex];
+				delete map[id];
+				--size;
+				if (base !== oldIndex) return;
+				if (!size) {
+					index = 0;
+					base = 1;
+					return;
+				}
+				while (!hasOwnProperty.call(queue, ++base)) continue; //jslint: skip
+			},
+			clear: function () {
+				size = 0;
+				base = 1;
+				queue = create(null);
+				map = create(null);
+				index = 0;
+			}
+		};
+	};
+
+
+/***/ },
+/* 119 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// Reference counter, useful for garbage collector like functionality
+
+	'use strict';
+
+	var d          = __webpack_require__(83)
+	  , extensions = __webpack_require__(72)
+
+	  , create = Object.create, defineProperties = Object.defineProperties;
+
+	extensions.refCounter = function (ignore, conf, options) {
+		var cache, postfix;
+
+		cache = create(null);
+		postfix = (options.async && extensions.async) ? 'async' : '';
+
+		conf.on('set' + postfix, function (id, length) { cache[id] = length || 1; });
+		conf.on('get' + postfix, function (id) { ++cache[id]; });
+		conf.on('delete' + postfix, function (id) { delete cache[id]; });
+		conf.on('clear' + postfix, function () { cache = {}; });
+
+		defineProperties(conf.memoized, {
+			deleteRef: d(function () {
+				var id = conf.get(arguments);
+				if (id === null) return null;
+				if (!cache[id]) return null;
+				if (!--cache[id]) {
+					conf.delete(id);
+					return true;
+				}
+				return false;
+			}),
+			getRefCount: d(function () {
+				var id = conf.get(arguments);
+				if (id === null) return 0;
+				if (!cache[id]) return 0;
+				return cache[id];
+			})
+		});
+	};
 
 
 /***/ }
diff --git a/vm.min.js b/vm.min.js
index 4b85be96a..4324eeba0 100644
--- a/vm.min.js
+++ b/vm.min.js
@@ -1 +1,11 @@
-!function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={exports:{},id:r,loaded:!1};return e[r].call(i.exports,i,i.exports,t),i.loaded=!0,i.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){function r(){var e=this;i.call(e),e.runtime=new s,e.blockListener=function(t){if("object"==typeof t&&"string"==typeof t.blockId){switch(t.type){case"create":e.runtime.createBlock({id:t.blockId,opcode:t.xml.attributes.type.value});break;case"move":e.runtime.moveBlock({id:t.blockId,oldParent:t.oldParentId,oldInput:t.oldInputName,newParent:t.newParentId,newInput:t.newInputName});break;case"change":e.runtime.changeBlock({id:t.blockId});break;case"delete":e.runtime.deleteBlock({id:t.blockId})}if("undefined"!=typeof t.element)switch(t.element){case"click":e.runtime.runStack({id:t.blockId})}}}}var i=n(1),o=n(2),s=n(6);o.inherits(r,i),r.prototype.start=function(){},r.prototype.stop=function(){},r.prototype.save=function(){},r.prototype.load=function(){},e.exports=r,"undefined"!=typeof window&&(window.VirtualMachine=e.exports)},function(e,t){function n(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function r(e){return"function"==typeof e}function i(e){return"number"==typeof e}function o(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}e.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0,n.defaultMaxListeners=10,n.prototype.setMaxListeners=function(e){if(!i(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},n.prototype.emit=function(e){var t,n,i,u,c,l;if(this._events||(this._events={}),"error"===e&&(!this._events.error||o(this._events.error)&&!this._events.error.length)){if(t=arguments[1],t instanceof Error)throw t;throw TypeError('Uncaught, unspecified "error" event.')}if(n=this._events[e],s(n))return!1;if(r(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:u=Array.prototype.slice.call(arguments,1),n.apply(this,u)}else if(o(n))for(u=Array.prototype.slice.call(arguments,1),l=n.slice(),i=l.length,c=0;i>c;c++)l[c].apply(this,u);return!0},n.prototype.addListener=function(e,t){var i;if(!r(t))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,r(t.listener)?t.listener:t),this._events[e]?o(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,o(this._events[e])&&!this._events[e].warned&&(i=s(this._maxListeners)?n.defaultMaxListeners:this._maxListeners,i&&i>0&&this._events[e].length>i&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())),this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(e,t){function n(){this.removeListener(e,n),i||(i=!0,t.apply(this,arguments))}if(!r(t))throw TypeError("listener must be a function");var i=!1;return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var n,i,s,u;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(n=this._events[e],s=n.length,i=-1,n===t||r(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(n)){for(u=s;u-- >0;)if(n[u]===t||n[u].listener&&n[u].listener===t){i=u;break}if(0>i)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},n.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(n=this._events[e],r(n))this.removeListener(e,n);else if(n)for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},n.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},n.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(r(t))return 1;if(t)return t.length}return 0},n.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,n){(function(e,r){function i(e,n){var r={seen:[],stylize:s};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),v(n)?r.showHidden=n:n&&t._extend(r,n),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=o),c(r,e,r.depth)}function o(e,t){var n=i.styles[t];return n?"["+i.colors[n][0]+"m"+e+"["+i.colors[n][1]+"m":e}function s(e,t){return e}function u(e){var t={};return e.forEach(function(e,n){t[e]=!0}),t}function c(e,n,r){if(e.customInspect&&n&&E(n.inspect)&&n.inspect!==t.inspect&&(!n.constructor||n.constructor.prototype!==n)){var i=n.inspect(r,e);return b(i)||(i=c(e,i,r)),i}var o=l(e,n);if(o)return o;var s=Object.keys(n),v=u(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(n)),L(n)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return a(n);if(0===s.length){if(E(n)){var y=n.name?": "+n.name:"";return e.stylize("[Function"+y+"]","special")}if(_(n))return e.stylize(RegExp.prototype.toString.call(n),"regexp");if(S(n))return e.stylize(Date.prototype.toString.call(n),"date");if(L(n))return a(n)}var g="",m=!1,k=["{","}"];if(d(n)&&(m=!0,k=["[","]"]),E(n)){var w=n.name?": "+n.name:"";g=" [Function"+w+"]"}if(_(n)&&(g=" "+RegExp.prototype.toString.call(n)),S(n)&&(g=" "+Date.prototype.toUTCString.call(n)),L(n)&&(g=" "+a(n)),0===s.length&&(!m||0==n.length))return k[0]+g+k[1];if(0>r)return _(n)?e.stylize(RegExp.prototype.toString.call(n),"regexp"):e.stylize("[Object]","special");e.seen.push(n);var x;return x=m?p(e,n,r,v,s):s.map(function(t){return f(e,n,r,v,t,m)}),e.seen.pop(),h(x,g,k)}function l(e,t){if(w(t))return e.stylize("undefined","undefined");if(b(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}return m(t)?e.stylize(""+t,"number"):v(t)?e.stylize(""+t,"boolean"):y(t)?e.stylize("null","null"):void 0}function a(e){return"["+Error.prototype.toString.call(e)+"]"}function p(e,t,n,r,i){for(var o=[],s=0,u=t.length;u>s;++s)z(t,String(s))?o.push(f(e,t,n,r,String(s),!0)):o.push("");return i.forEach(function(i){i.match(/^\d+$/)||o.push(f(e,t,n,r,i,!0))}),o}function f(e,t,n,r,i,o){var s,u,l;if(l=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]},l.get?u=l.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):l.set&&(u=e.stylize("[Setter]","special")),z(r,i)||(s="["+i+"]"),u||(e.seen.indexOf(l.value)<0?(u=y(n)?c(e,l.value,null):c(e,l.value,n-1),u.indexOf("\n")>-1&&(u=o?u.split("\n").map(function(e){return"  "+e}).join("\n").substr(2):"\n"+u.split("\n").map(function(e){return"   "+e}).join("\n"))):u=e.stylize("[Circular]","special")),w(s)){if(o&&i.match(/^\d+$/))return u;s=JSON.stringify(""+i),s.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+u}function h(e,t,n){var r=0,i=e.reduce(function(e,t){return r++,t.indexOf("\n")>=0&&r++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return i>60?n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+n[1]:n[0]+t+" "+e.join(", ")+" "+n[1]}function d(e){return Array.isArray(e)}function v(e){return"boolean"==typeof e}function y(e){return null===e}function g(e){return null==e}function m(e){return"number"==typeof e}function b(e){return"string"==typeof e}function k(e){return"symbol"==typeof e}function w(e){return void 0===e}function _(e){return x(e)&&"[object RegExp]"===O(e)}function x(e){return"object"==typeof e&&null!==e}function S(e){return x(e)&&"[object Date]"===O(e)}function L(e){return x(e)&&("[object Error]"===O(e)||e instanceof Error)}function E(e){return"function"==typeof e}function j(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function O(e){return Object.prototype.toString.call(e)}function T(e){return 10>e?"0"+e.toString(10):e.toString(10)}function I(){var e=new Date,t=[T(e.getHours()),T(e.getMinutes()),T(e.getSeconds())].join(":");return[e.getDate(),P[e.getMonth()],t].join(" ")}function z(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var B=/%[sdj%]/g;t.format=function(e){if(!b(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(i(arguments[n]));return t.join(" ")}for(var n=1,r=arguments,o=r.length,s=String(e).replace(B,function(e){if("%%"===e)return"%";if(n>=o)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(t){return"[Circular]"}default:return e}}),u=r[n];o>n;u=r[++n])s+=y(u)||!x(u)?" "+u:" "+i(u);return s},t.deprecate=function(n,i){function o(){if(!s){if(r.throwDeprecation)throw new Error(i);r.traceDeprecation?console.trace(i):console.error(i),s=!0}return n.apply(this,arguments)}if(w(e.process))return function(){return t.deprecate(n,i).apply(this,arguments)};if(r.noDeprecation===!0)return n;var s=!1;return o};var A,D={};t.debuglog=function(e){if(w(A)&&(A=r.env.NODE_DEBUG||""),e=e.toUpperCase(),!D[e])if(new RegExp("\\b"+e+"\\b","i").test(A)){var n=r.pid;D[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,n,r)}}else D[e]=function(){};return D[e]},t.inspect=i,i.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]},i.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=d,t.isBoolean=v,t.isNull=y,t.isNullOrUndefined=g,t.isNumber=m,t.isString=b,t.isSymbol=k,t.isUndefined=w,t.isRegExp=_,t.isObject=x,t.isDate=S,t.isError=L,t.isFunction=E,t.isPrimitive=j,t.isBuffer=n(4);var P=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];t.log=function(){console.log("%s - %s",I(),t.format.apply(t,arguments))},t.inherits=n(5),t._extend=function(e,t){if(!t||!x(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(t,function(){return this}(),n(3))},function(e,t){function n(){l=!1,s.length?c=s.concat(c):a=-1,c.length&&r()}function r(){if(!l){var e=setTimeout(n);l=!0;for(var t=c.length;t;){for(s=c,c=[];++a<t;)s&&s[a].run();a=-1,t=c.length}s=null,l=!1,clearTimeout(e)}}function i(e,t){this.fun=e,this.array=t}function o(){}var s,u=e.exports={},c=[],l=!1,a=-1;u.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];c.push(new i(e,t)),1!==c.length||l||setTimeout(r,0)},i.prototype.run=function(){this.fun.apply(null,this.array)},u.title="browser",u.browser=!0,u.env={},u.argv=[],u.version="",u.versions={},u.on=o,u.addListener=o,u.once=o,u.off=o,u.removeListener=o,u.removeAllListeners=o,u.emit=o,u.binding=function(e){throw new Error("process.binding is not supported")},u.cwd=function(){return"/"},u.chdir=function(e){throw new Error("process.chdir is not supported")},u.umask=function(){return 0}},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t){"function"==typeof Object.create?e.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},function(e,t,n){function r(){i.call(instance),this.sequencer=new u(this),this.primitives=new s,this.blocks={},this.stacks=[]}var i=n(1),o=n(2),s=n(7),u=n(8);n(10);o.inherits(r,i),r.prototype.createBlock=function(e){this.blocks[e.id]={id:e.id,opcode:e.opcode,next:null,inputs:{}},this.stacks.push(e.id)},r.prototype.moveBlock=function(e){var t=this;void 0===e.oldParent&&void 0!==e.newParent&&(t._deleteStack(e.id),void 0===e.newInput?t.blocks[e.newParent].next=e.id:t.blocks[e.newParent].inputs[e.newInput]=e.id),void 0===e.newParentId&&void 0!==e.oldParent&&(t.stacks.push(e.id),void 0===e.oldInput?t.blocks[e.oldParent].next=null:delete t.blocks[e.oldParent].inputs[e.oldInput])},r.prototype.changeBlock=function(e){},r.prototype.deleteBlock=function(e){var t=this.blocks[e.id];null!==t.next&&this.deleteBlock({id:t.next});for(var n in t.inputs)this.deleteBlock({id:t.inputs[n]});this._deleteStack(e.id),delete this.blocks[e.id]},r.prototype.runAllStacks=function(){},r.prototype.runStack=function(e){console.dir(e)},r.prototype.stopAllStacks=function(){},r.prototype._deleteStack=function(e){var t=this.stacks.indexOf(e);t>-1&&this.stacks.splice(t,1)},r.prototype._getNextBlock=function(e){return"undefined"==typeof this.blocks[e]?null:this.blocks[e].next},r.prototype._getSubstack=function(e){return"undefined"==typeof this.blocks[e]?null:this.blocks[e].inputs.SUBSTACK},e.exports=r},function(e,t){function n(){}n.prototype.event_whenflagclicked=function(e,t){return Date.now()-e.blockFirstTime<300?void(e["yield"]=!0):void 0},n.prototype.control_repeat=function(e,t){return Date.now()-e.blockFirstTime<300?void(e["yield"]=!0):(-1==e.repeatCounter&&(e.repeatCounter=10),void(e.repeatCounter>0?(e.repeatCounter-=1,t.interpreter.startSubstack(e)):(e.repeatCounter=-1,e.nextBlock=t.getNextBlock(e.blockPointer))))},n.prototype.control_forever=function(e,t){return Date.now()-e.blockFirstTime<300?void(e["yield"]=!0):void t.interpreter.startSubstack(e)},e.exports=n},function(e,t,n){function r(e){this.runtime=e,this.runningThreads=[],this.workTime=30,this.timer=new i,this.currentTime=0}var i=n(9);r.prototype.stepAllThreads=function(){},r.prototype.stepThread=function(e){},r.prototype.startSubstack=function(e){},e.exports=r},function(e,t){function n(){this.startTime=0}n.prototype.time=function(){return Date.now()},n.prototype.start=function(){this.startTime=this.time()},n.prototype.stop=function(){return this.startTime-this.time()},e.exports=n},function(e,t){function n(e){this.topBlockId=e,this.blockPointer=e,this.blockFirstTime=-1,this.nextBlock=null,this.waiting=null,this.runningDeviceBlock=!1,this.stack=[],this.repeatCounter=-1}e.exports=n}]);
\ No newline at end of file
+!function(t){function e(n){if(r[n])return r[n].exports;var i=r[n]={exports:{},id:n,loaded:!1};return t[n].call(i.exports,i,i.exports,e),i.loaded=!0,i.exports}var r={};return e.m=t,e.c=r,e.p="",e(0)}([function(t,e,r){function n(){var t=this;i.call(t),t.runtime=new s,t.blockListener=function(e){if("object"==typeof e&&"string"==typeof e.blockId)switch(e.type){case"create":t.runtime.createBlock(a(e));break;case"change":t.runtime.changeBlock({id:e.blockId,element:e.element,name:e.name,value:e.newValue});break;case"move":t.runtime.moveBlock({id:e.blockId,oldParent:e.oldParentId,oldField:e.oldInputName,newParent:e.newParentId,newField:e.newInputName});break;case"delete":t.runtime.deleteBlock({id:e.blockId})}}}var i=r(1),o=r(2),s=r(6),a=r(7);o.inherits(n,i),t.exports=n,"undefined"!=typeof window&&(window.VirtualMachine=t.exports)},function(t,e){function r(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function n(t){return"function"==typeof t}function i(t){return"number"==typeof t}function o(t){return"object"==typeof t&&null!==t}function s(t){return void 0===t}t.exports=r,r.EventEmitter=r,r.prototype._events=void 0,r.prototype._maxListeners=void 0,r.defaultMaxListeners=10,r.prototype.setMaxListeners=function(t){if(!i(t)||0>t||isNaN(t))throw TypeError("n must be a positive number");return this._maxListeners=t,this},r.prototype.emit=function(t){var e,r,i,a,c,u;if(this._events||(this._events={}),"error"===t&&(!this._events.error||o(this._events.error)&&!this._events.error.length)){if(e=arguments[1],e instanceof Error)throw e;throw TypeError('Uncaught, unspecified "error" event.')}if(r=this._events[t],s(r))return!1;if(n(r))switch(arguments.length){case 1:r.call(this);break;case 2:r.call(this,arguments[1]);break;case 3:r.call(this,arguments[1],arguments[2]);break;default:a=Array.prototype.slice.call(arguments,1),r.apply(this,a)}else if(o(r))for(a=Array.prototype.slice.call(arguments,1),u=r.slice(),i=u.length,c=0;i>c;c++)u[c].apply(this,a);return!0},r.prototype.addListener=function(t,e){var i;if(!n(e))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",t,n(e.listener)?e.listener:e),this._events[t]?o(this._events[t])?this._events[t].push(e):this._events[t]=[this._events[t],e]:this._events[t]=e,o(this._events[t])&&!this._events[t].warned&&(i=s(this._maxListeners)?r.defaultMaxListeners:this._maxListeners,i&&i>0&&this._events[t].length>i&&(this._events[t].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[t].length),"function"==typeof console.trace&&console.trace())),this},r.prototype.on=r.prototype.addListener,r.prototype.once=function(t,e){function r(){this.removeListener(t,r),i||(i=!0,e.apply(this,arguments))}if(!n(e))throw TypeError("listener must be a function");var i=!1;return r.listener=e,this.on(t,r),this},r.prototype.removeListener=function(t,e){var r,i,s,a;if(!n(e))throw TypeError("listener must be a function");if(!this._events||!this._events[t])return this;if(r=this._events[t],s=r.length,i=-1,r===e||n(r.listener)&&r.listener===e)delete this._events[t],this._events.removeListener&&this.emit("removeListener",t,e);else if(o(r)){for(a=s;a-- >0;)if(r[a]===e||r[a].listener&&r[a].listener===e){i=a;break}if(0>i)return this;1===r.length?(r.length=0,delete this._events[t]):r.splice(i,1),this._events.removeListener&&this.emit("removeListener",t,e)}return this},r.prototype.removeAllListeners=function(t){var e,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[t]&&delete this._events[t],this;if(0===arguments.length){for(e in this._events)"removeListener"!==e&&this.removeAllListeners(e);return this.removeAllListeners("removeListener"),this._events={},this}if(r=this._events[t],n(r))this.removeListener(t,r);else if(r)for(;r.length;)this.removeListener(t,r[r.length-1]);return delete this._events[t],this},r.prototype.listeners=function(t){var e;return e=this._events&&this._events[t]?n(this._events[t])?[this._events[t]]:this._events[t].slice():[]},r.prototype.listenerCount=function(t){if(this._events){var e=this._events[t];if(n(e))return 1;if(e)return e.length}return 0},r.listenerCount=function(t,e){return t.listenerCount(e)}},function(t,e,r){(function(t,n){function i(t,r){var n={seen:[],stylize:s};return arguments.length>=3&&(n.depth=arguments[2]),arguments.length>=4&&(n.colors=arguments[3]),g(r)?n.showHidden=r:r&&e._extend(n,r),w(n.showHidden)&&(n.showHidden=!1),w(n.depth)&&(n.depth=2),w(n.colors)&&(n.colors=!1),w(n.customInspect)&&(n.customInspect=!0),n.colors&&(n.stylize=o),c(n,t,n.depth)}function o(t,e){var r=i.styles[e];return r?"["+i.colors[r][0]+"m"+t+"["+i.colors[r][1]+"m":t}function s(t,e){return t}function a(t){var e={};return t.forEach(function(t,r){e[t]=!0}),e}function c(t,r,n){if(t.customInspect&&r&&T(r.inspect)&&r.inspect!==e.inspect&&(!r.constructor||r.constructor.prototype!==r)){var i=r.inspect(n,t);return y(i)||(i=c(t,i,n)),i}var o=u(t,r);if(o)return o;var s=Object.keys(r),g=a(s);if(t.showHidden&&(s=Object.getOwnPropertyNames(r)),A(r)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return l(r);if(0===s.length){if(T(r)){var b=r.name?": "+r.name:"";return t.stylize("[Function"+b+"]","special")}if(x(r))return t.stylize(RegExp.prototype.toString.call(r),"regexp");if(E(r))return t.stylize(Date.prototype.toString.call(r),"date");if(A(r))return l(r)}var _="",m=!1,v=["{","}"];if(d(r)&&(m=!0,v=["[","]"]),T(r)){var w=r.name?": "+r.name:"";_=" [Function"+w+"]"}if(x(r)&&(_=" "+RegExp.prototype.toString.call(r)),E(r)&&(_=" "+Date.prototype.toUTCString.call(r)),A(r)&&(_=" "+l(r)),0===s.length&&(!m||0==r.length))return v[0]+_+v[1];if(0>n)return x(r)?t.stylize(RegExp.prototype.toString.call(r),"regexp"):t.stylize("[Object]","special");t.seen.push(r);var S;return S=m?h(t,r,n,g,s):s.map(function(e){return f(t,r,n,g,e,m)}),t.seen.pop(),p(S,_,v)}function u(t,e){if(w(e))return t.stylize("undefined","undefined");if(y(e)){var r="'"+JSON.stringify(e).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return t.stylize(r,"string")}return m(e)?t.stylize(""+e,"number"):g(e)?t.stylize(""+e,"boolean"):b(e)?t.stylize("null","null"):void 0}function l(t){return"["+Error.prototype.toString.call(t)+"]"}function h(t,e,r,n,i){for(var o=[],s=0,a=e.length;a>s;++s)C(e,String(s))?o.push(f(t,e,r,n,String(s),!0)):o.push("");return i.forEach(function(i){i.match(/^\d+$/)||o.push(f(t,e,r,n,i,!0))}),o}function f(t,e,r,n,i,o){var s,a,u;if(u=Object.getOwnPropertyDescriptor(e,i)||{value:e[i]},u.get?a=u.set?t.stylize("[Getter/Setter]","special"):t.stylize("[Getter]","special"):u.set&&(a=t.stylize("[Setter]","special")),C(n,i)||(s="["+i+"]"),a||(t.seen.indexOf(u.value)<0?(a=b(r)?c(t,u.value,null):c(t,u.value,r-1),a.indexOf("\n")>-1&&(a=o?a.split("\n").map(function(t){return"  "+t}).join("\n").substr(2):"\n"+a.split("\n").map(function(t){return"   "+t}).join("\n"))):a=t.stylize("[Circular]","special")),w(s)){if(o&&i.match(/^\d+$/))return a;s=JSON.stringify(""+i),s.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=t.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=t.stylize(s,"string"))}return s+": "+a}function p(t,e,r){var n=0,i=t.reduce(function(t,e){return n++,e.indexOf("\n")>=0&&n++,t+e.replace(/\u001b\[\d\d?m/g,"").length+1},0);return i>60?r[0]+(""===e?"":e+"\n ")+" "+t.join(",\n  ")+" "+r[1]:r[0]+e+" "+t.join(", ")+" "+r[1]}function d(t){return Array.isArray(t)}function g(t){return"boolean"==typeof t}function b(t){return null===t}function _(t){return null==t}function m(t){return"number"==typeof t}function y(t){return"string"==typeof t}function v(t){return"symbol"==typeof t}function w(t){return void 0===t}function x(t){return S(t)&&"[object RegExp]"===L(t)}function S(t){return"object"==typeof t&&null!==t}function E(t){return S(t)&&"[object Date]"===L(t)}function A(t){return S(t)&&("[object Error]"===L(t)||t instanceof Error)}function T(t){return"function"==typeof t}function k(t){return null===t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||"symbol"==typeof t||"undefined"==typeof t}function L(t){return Object.prototype.toString.call(t)}function O(t){return 10>t?"0"+t.toString(10):t.toString(10)}function I(){var t=new Date,e=[O(t.getHours()),O(t.getMinutes()),O(t.getSeconds())].join(":");return[t.getDate(),q[t.getMonth()],e].join(" ")}function C(t,e){return Object.prototype.hasOwnProperty.call(t,e)}var D=/%[sdj%]/g;e.format=function(t){if(!y(t)){for(var e=[],r=0;r<arguments.length;r++)e.push(i(arguments[r]));return e.join(" ")}for(var r=1,n=arguments,o=n.length,s=String(t).replace(D,function(t){if("%%"===t)return"%";if(r>=o)return t;switch(t){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return JSON.stringify(n[r++])}catch(e){return"[Circular]"}default:return t}}),a=n[r];o>r;a=n[++r])s+=b(a)||!S(a)?" "+a:" "+i(a);return s},e.deprecate=function(r,i){function o(){if(!s){if(n.throwDeprecation)throw new Error(i);n.traceDeprecation?console.trace(i):console.error(i),s=!0}return r.apply(this,arguments)}if(w(t.process))return function(){return e.deprecate(r,i).apply(this,arguments)};if(n.noDeprecation===!0)return r;var s=!1;return o};var B,R={};e.debuglog=function(t){if(w(B)&&(B=n.env.NODE_DEBUG||""),t=t.toUpperCase(),!R[t])if(new RegExp("\\b"+t+"\\b","i").test(B)){var r=n.pid;R[t]=function(){var n=e.format.apply(e,arguments);console.error("%s %d: %s",t,r,n)}}else R[t]=function(){};return R[t]},e.inspect=i,i.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]},i.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},e.isArray=d,e.isBoolean=g,e.isNull=b,e.isNullOrUndefined=_,e.isNumber=m,e.isString=y,e.isSymbol=v,e.isUndefined=w,e.isRegExp=x,e.isObject=S,e.isDate=E,e.isError=A,e.isFunction=T,e.isPrimitive=k,e.isBuffer=r(4);var q=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];e.log=function(){console.log("%s - %s",I(),e.format.apply(e,arguments))},e.inherits=r(5),e._extend=function(t,e){if(!e||!S(e))return t;for(var r=Object.keys(e),n=r.length;n--;)t[r[n]]=e[r[n]];return t}}).call(e,function(){return this}(),r(3))},function(t,e){function r(){u=!1,s.length?c=s.concat(c):l=-1,c.length&&n()}function n(){if(!u){var t=setTimeout(r);u=!0;for(var e=c.length;e;){for(s=c,c=[];++l<e;)s&&s[l].run();l=-1,e=c.length}s=null,u=!1,clearTimeout(t)}}function i(t,e){this.fun=t,this.array=e}function o(){}var s,a=t.exports={},c=[],u=!1,l=-1;a.nextTick=function(t){var e=new Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)e[r-1]=arguments[r];c.push(new i(t,e)),1!==c.length||u||setTimeout(n,0)},i.prototype.run=function(){this.fun.apply(null,this.array)},a.title="browser",a.browser=!0,a.env={},a.argv=[],a.version="",a.versions={},a.on=o,a.addListener=o,a.once=o,a.off=o,a.removeListener=o,a.removeAllListeners=o,a.emit=o,a.binding=function(t){throw new Error("process.binding is not supported")},a.cwd=function(){return"/"},a.chdir=function(t){throw new Error("process.chdir is not supported")},a.umask=function(){return 0}},function(t,e){t.exports=function(t){return t&&"object"==typeof t&&"function"==typeof t.copy&&"function"==typeof t.fill&&"function"==typeof t.readUInt8}},function(t,e){"function"==typeof Object.create?t.exports=function(t,e){t.super_=e,t.prototype=Object.create(e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(t,e){t.super_=e;var r=function(){};r.prototype=e.prototype,t.prototype=new r,t.prototype.constructor=t}},function(t,e,r){function n(){i.call(this),this.blocks={},this.stacks=[],window._BLOCKS=this.blocks,window._STACKS=this.stacks}var i=r(1),o=r(2);o.inherits(n,i),n.prototype.createBlock=function(t){this.blocks[t.id]=t;for(var e in t.fields){var r=t.fields[e].blocks;for(var n in r){var i=r[n];this.blocks[i.id]=i}}this.stacks.push(t.id)},n.prototype.changeBlock=function(t){"field"===t.element&&"undefined"!=typeof this.blocks[t.id]&&"undefined"!=typeof this.blocks[t.id].fields[t.name]&&(this.blocks[t.id].fields[t.name].value=t.value)},n.prototype.moveBlock=function(t){var e=this;void 0===t.oldParent&&void 0!==t.newParent&&(e._deleteStack(t.id),void 0===t.newField?e.blocks[t.newParent].next=t.id:e.blocks[t.newParent].fields[t.newField]={name:t.newField,value:t.id,blocks:{}}),void 0===t.newParentId&&void 0!==t.oldParent&&(e.stacks.push(t.id),void 0===t.oldField?e.blocks[t.oldParent].next=null:delete e.blocks[t.oldParent].fields[t.oldField])},n.prototype.deleteBlock=function(t){var e=this.blocks[t.id];null!==e.next&&this.deleteBlock({id:e.next});for(var r in e.fields)if("SUBSTACK"===r)this.deleteBlock({id:e.fields[r].value});else for(var n in e.fields[r].blocks)this.deleteBlock({id:n});this._deleteStack(t.id),delete this.blocks[t.id]},n.prototype._deleteStack=function(t){var e=this.stacks.indexOf(t);e>-1&&this.stacks.splice(e,1)},n.prototype._getNextBlock=function(t){return"undefined"==typeof this.blocks[t]?null:this.blocks[t].next},n.prototype._getSubstack=function(t){return"undefined"==typeof this.blocks[t]?null:this.blocks[t].fields.SUBSTACK},t.exports=n},function(t,e,r){function n(t){var e={},r=t[0],n=r.attribs.name;e[n]={name:n,value:null,blocks:{}};var i=r.children[0],o=i.attribs.id,s=i.attribs.type;e[n].blocks[o]={id:o,opcode:s,next:null,fields:{}};var a=i.children[0],c=a.attribs.name,u=a.children[0].data;return e[n].blocks[o].fields[c]={name:c,value:u,blocks:null},e}var i=r(8),o=r(59),s=o(i.parseDOM,{length:1,resolvers:[String],max:200});t.exports=function(t){if("object"==typeof t&&"string"==typeof t.blockId&&"object"==typeof t.xml){var e={id:t.blockId,opcode:null,next:null,fields:{}};return"object"==typeof t.xml.attributes&&(e.opcode=t.xml.attributes.type.value),"string"!=typeof t.xml.innerHTML?e:""===t.xml.innerHTML?e:(e.fields=n(s(t.xml.innerHTML)),e)}}},function(t,e,r){function n(e,r){return delete t.exports[e],t.exports[e]=r,r}var i=r(9),o=r(16);t.exports={Parser:i,Tokenizer:r(10),ElementType:r(17),DomHandler:o,get FeedHandler(){return n("FeedHandler",r(20))},get Stream(){return n("Stream",r(21))},get WritableStream(){return n("WritableStream",r(22))},get ProxyHandler(){return n("ProxyHandler",r(45))},get DomUtils(){return n("DomUtils",r(46))},get CollectingHandler(){return n("CollectingHandler",r(58))},DefaultHandler:o,get RssHandler(){return n("RssHandler",this.FeedHandler)},parseDOM:function(t,e){var r=new o(e);return new i(r,e).end(t),r.dom},parseFeed:function(e,r){var n=new t.exports.FeedHandler(r);return new i(n,r).end(e),n.dom},createDomStream:function(t,e,r){var n=new o(t,e,r);return new i(n,e)},EVENTS:{attribute:2,cdatastart:0,cdataend:0,text:1,processinginstruction:2,comment:1,commentend:0,closetag:1,opentag:2,opentagname:1,error:1,end:0}}},function(t,e,r){function n(t,e){this._options=e||{},this._cbs=t||{},this._tagname="",this._attribname="",this._attribvalue="",this._attribs=null,this._stack=[],this.startIndex=0,this.endIndex=null,this._lowerCaseTagNames="lowerCaseTags"in this._options?!!this._options.lowerCaseTags:!this._options.xmlMode,this._lowerCaseAttributeNames="lowerCaseAttributeNames"in this._options?!!this._options.lowerCaseAttributeNames:!this._options.xmlMode,this._options.Tokenizer&&(i=this._options.Tokenizer),this._tokenizer=new i(this._options,this),this._cbs.onparserinit&&this._cbs.onparserinit(this)}var i=r(10),o={input:!0,option:!0,optgroup:!0,select:!0,button:!0,datalist:!0,textarea:!0},s={tr:{tr:!0,th:!0,td:!0},th:{th:!0},td:{thead:!0,th:!0,td:!0},body:{head:!0,link:!0,script:!0},li:{li:!0},p:{p:!0},h1:{p:!0},h2:{p:!0},h3:{p:!0},h4:{p:!0},h5:{p:!0},h6:{p:!0},select:o,input:o,output:o,button:o,datalist:o,textarea:o,option:{option:!0},optgroup:{optgroup:!0}},a={__proto__:null,area:!0,base:!0,basefont:!0,br:!0,col:!0,command:!0,embed:!0,frame:!0,hr:!0,img:!0,input:!0,isindex:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0,path:!0,circle:!0,ellipse:!0,line:!0,rect:!0,use:!0,stop:!0,polyline:!0,polygon:!0},c=/\s|\//;r(2).inherits(n,r(1).EventEmitter),n.prototype._updatePosition=function(t){null===this.endIndex?this._tokenizer._sectionStart<=t?this.startIndex=0:this.startIndex=this._tokenizer._sectionStart-t:this.startIndex=this.endIndex+1,this.endIndex=this._tokenizer.getAbsoluteIndex()},n.prototype.ontext=function(t){this._updatePosition(1),this.endIndex--,this._cbs.ontext&&this._cbs.ontext(t)},n.prototype.onopentagname=function(t){if(this._lowerCaseTagNames&&(t=t.toLowerCase()),this._tagname=t,!this._options.xmlMode&&t in s)for(var e;(e=this._stack[this._stack.length-1])in s[t];this.onclosetag(e));!this._options.xmlMode&&t in a||this._stack.push(t),this._cbs.onopentagname&&this._cbs.onopentagname(t),this._cbs.onopentag&&(this._attribs={})},n.prototype.onopentagend=function(){this._updatePosition(1),this._attribs&&(this._cbs.onopentag&&this._cbs.onopentag(this._tagname,this._attribs),this._attribs=null),!this._options.xmlMode&&this._cbs.onclosetag&&this._tagname in a&&this._cbs.onclosetag(this._tagname),this._tagname=""},n.prototype.onclosetag=function(t){if(this._updatePosition(1),this._lowerCaseTagNames&&(t=t.toLowerCase()),!this._stack.length||t in a&&!this._options.xmlMode)this._options.xmlMode||"br"!==t&&"p"!==t||(this.onopentagname(t),this._closeCurrentTag());else{var e=this._stack.lastIndexOf(t);if(-1!==e)if(this._cbs.onclosetag)for(e=this._stack.length-e;e--;)this._cbs.onclosetag(this._stack.pop());else this._stack.length=e;else"p"!==t||this._options.xmlMode||(this.onopentagname(t),this._closeCurrentTag())}},n.prototype.onselfclosingtag=function(){this._options.xmlMode||this._options.recognizeSelfClosing?this._closeCurrentTag():this.onopentagend()},n.prototype._closeCurrentTag=function(){var t=this._tagname;this.onopentagend(),this._stack[this._stack.length-1]===t&&(this._cbs.onclosetag&&this._cbs.onclosetag(t),this._stack.pop())},n.prototype.onattribname=function(t){this._lowerCaseAttributeNames&&(t=t.toLowerCase()),this._attribname=t},n.prototype.onattribdata=function(t){this._attribvalue+=t},n.prototype.onattribend=function(){this._cbs.onattribute&&this._cbs.onattribute(this._attribname,this._attribvalue),this._attribs&&!Object.prototype.hasOwnProperty.call(this._attribs,this._attribname)&&(this._attribs[this._attribname]=this._attribvalue),this._attribname="",this._attribvalue=""},n.prototype._getInstructionName=function(t){var e=t.search(c),r=0>e?t:t.substr(0,e);return this._lowerCaseTagNames&&(r=r.toLowerCase()),r},n.prototype.ondeclaration=function(t){if(this._cbs.onprocessinginstruction){var e=this._getInstructionName(t);this._cbs.onprocessinginstruction("!"+e,"!"+t)}},n.prototype.onprocessinginstruction=function(t){if(this._cbs.onprocessinginstruction){var e=this._getInstructionName(t);this._cbs.onprocessinginstruction("?"+e,"?"+t)}},n.prototype.oncomment=function(t){this._updatePosition(4),this._cbs.oncomment&&this._cbs.oncomment(t),this._cbs.oncommentend&&this._cbs.oncommentend()},n.prototype.oncdata=function(t){this._updatePosition(1),this._options.xmlMode||this._options.recognizeCDATA?(this._cbs.oncdatastart&&this._cbs.oncdatastart(),this._cbs.ontext&&this._cbs.ontext(t),this._cbs.oncdataend&&this._cbs.oncdataend()):this.oncomment("[CDATA["+t+"]]")},n.prototype.onerror=function(t){this._cbs.onerror&&this._cbs.onerror(t)},n.prototype.onend=function(){if(this._cbs.onclosetag)for(var t=this._stack.length;t>0;this._cbs.onclosetag(this._stack[--t]));this._cbs.onend&&this._cbs.onend()},n.prototype.reset=function(){this._cbs.onreset&&this._cbs.onreset(),this._tokenizer.reset(),this._tagname="",this._attribname="",this._attribs=null,this._stack=[],this._cbs.onparserinit&&this._cbs.onparserinit(this)},n.prototype.parseComplete=function(t){this.reset(),this.end(t)},n.prototype.write=function(t){this._tokenizer.write(t)},n.prototype.end=function(t){this._tokenizer.end(t)},n.prototype.pause=function(){this._tokenizer.pause()},n.prototype.resume=function(){this._tokenizer.resume()},n.prototype.parseChunk=n.prototype.write,n.prototype.done=n.prototype.end,t.exports=n},function(t,e,r){function n(t){return" "===t||"\n"===t||"	"===t||"\f"===t||"\r"===t}function i(t,e){return function(r){r===t&&(this._state=e)}}function o(t,e,r){var n=t.toLowerCase();return t===n?function(t){t===n?this._state=e:(this._state=r,this._index--)}:function(i){i===n||i===t?this._state=e:(this._state=r,this._index--)}}function s(t,e){var r=t.toLowerCase();return function(n){n===r||n===t?this._state=e:(this._state=g,this._index--)}}function a(t,e){this._state=p,this._buffer="",this._sectionStart=0,this._index=0,this._bufferOffset=0,this._baseState=p,this._special=gt,this._cbs=e,this._running=!0,this._ended=!1,this._xmlMode=!(!t||!t.xmlMode),this._decodeEntities=!(!t||!t.decodeEntities)}t.exports=a;var c=r(11),u=r(13),l=r(14),h=r(15),f=0,p=f++,d=f++,g=f++,b=f++,_=f++,m=f++,y=f++,v=f++,w=f++,x=f++,S=f++,E=f++,A=f++,T=f++,k=f++,L=f++,O=f++,I=f++,C=f++,D=f++,B=f++,R=f++,q=f++,N=f++,j=f++,P=f++,M=f++,U=f++,z=f++,F=f++,H=f++,V=f++,Y=f++,G=f++,W=f++,J=f++,X=f++,Q=f++,Z=f++,K=f++,$=f++,tt=f++,et=f++,rt=f++,nt=f++,it=f++,ot=f++,st=f++,at=f++,ct=f++,ut=f++,lt=f++,ht=f++,ft=f++,pt=f++,dt=0,gt=dt++,bt=dt++,_t=dt++;a.prototype._stateText=function(t){"<"===t?(this._index>this._sectionStart&&this._cbs.ontext(this._getSection()),this._state=d,this._sectionStart=this._index):this._decodeEntities&&this._special===gt&&"&"===t&&(this._index>this._sectionStart&&this._cbs.ontext(this._getSection()),this._baseState=p,this._state=ut,this._sectionStart=this._index)},a.prototype._stateBeforeTagName=function(t){"/"===t?this._state=_:">"===t||this._special!==gt||n(t)?this._state=p:"!"===t?(this._state=k,this._sectionStart=this._index+1):"?"===t?(this._state=O,this._sectionStart=this._index+1):"<"===t?(this._cbs.ontext(this._getSection()),this._sectionStart=this._index):(this._state=this._xmlMode||"s"!==t&&"S"!==t?g:H,this._sectionStart=this._index)},a.prototype._stateInTagName=function(t){("/"===t||">"===t||n(t))&&(this._emitToken("onopentagname"),this._state=v,this._index--)},a.prototype._stateBeforeCloseingTagName=function(t){n(t)||(">"===t?this._state=p:this._special!==gt?"s"===t||"S"===t?this._state=V:(this._state=p,this._index--):(this._state=m,this._sectionStart=this._index))},a.prototype._stateInCloseingTagName=function(t){(">"===t||n(t))&&(this._emitToken("onclosetag"),this._state=y,this._index--)},a.prototype._stateAfterCloseingTagName=function(t){">"===t&&(this._state=p,this._sectionStart=this._index+1)},a.prototype._stateBeforeAttributeName=function(t){">"===t?(this._cbs.onopentagend(),this._state=p,this._sectionStart=this._index+1):"/"===t?this._state=b:n(t)||(this._state=w,this._sectionStart=this._index)},a.prototype._stateInSelfClosingTag=function(t){">"===t?(this._cbs.onselfclosingtag(),this._state=p,this._sectionStart=this._index+1):n(t)||(this._state=v,this._index--)},a.prototype._stateInAttributeName=function(t){("="===t||"/"===t||">"===t||n(t))&&(this._cbs.onattribname(this._getSection()),this._sectionStart=-1,this._state=x,this._index--)},a.prototype._stateAfterAttributeName=function(t){"="===t?this._state=S:"/"===t||">"===t?(this._cbs.onattribend(),this._state=v,this._index--):n(t)||(this._cbs.onattribend(),this._state=w,this._sectionStart=this._index)},a.prototype._stateBeforeAttributeValue=function(t){'"'===t?(this._state=E,this._sectionStart=this._index+1):"'"===t?(this._state=A,this._sectionStart=this._index+1):n(t)||(this._state=T,this._sectionStart=this._index,this._index--)},a.prototype._stateInAttributeValueDoubleQuotes=function(t){'"'===t?(this._emitToken("onattribdata"),this._cbs.onattribend(),this._state=v):this._decodeEntities&&"&"===t&&(this._emitToken("onattribdata"),this._baseState=this._state,this._state=ut,this._sectionStart=this._index)},a.prototype._stateInAttributeValueSingleQuotes=function(t){"'"===t?(this._emitToken("onattribdata"),this._cbs.onattribend(),this._state=v):this._decodeEntities&&"&"===t&&(this._emitToken("onattribdata"),this._baseState=this._state,this._state=ut,this._sectionStart=this._index)},a.prototype._stateInAttributeValueNoQuotes=function(t){n(t)||">"===t?(this._emitToken("onattribdata"),this._cbs.onattribend(),this._state=v,this._index--):this._decodeEntities&&"&"===t&&(this._emitToken("onattribdata"),this._baseState=this._state,this._state=ut,this._sectionStart=this._index)},a.prototype._stateBeforeDeclaration=function(t){this._state="["===t?R:"-"===t?I:L},a.prototype._stateInDeclaration=function(t){">"===t&&(this._cbs.ondeclaration(this._getSection()),this._state=p,this._sectionStart=this._index+1)},a.prototype._stateInProcessingInstruction=function(t){">"===t&&(this._cbs.onprocessinginstruction(this._getSection()),this._state=p,this._sectionStart=this._index+1)},a.prototype._stateBeforeComment=function(t){"-"===t?(this._state=C,this._sectionStart=this._index+1):this._state=L},a.prototype._stateInComment=function(t){"-"===t&&(this._state=D)},a.prototype._stateAfterComment1=function(t){"-"===t?this._state=B:this._state=C},a.prototype._stateAfterComment2=function(t){">"===t?(this._cbs.oncomment(this._buffer.substring(this._sectionStart,this._index-2)),this._state=p,this._sectionStart=this._index+1):"-"!==t&&(this._state=C)},a.prototype._stateBeforeCdata1=o("C",q,L),a.prototype._stateBeforeCdata2=o("D",N,L),a.prototype._stateBeforeCdata3=o("A",j,L),a.prototype._stateBeforeCdata4=o("T",P,L),a.prototype._stateBeforeCdata5=o("A",M,L),a.prototype._stateBeforeCdata6=function(t){"["===t?(this._state=U,this._sectionStart=this._index+1):(this._state=L,this._index--)},a.prototype._stateInCdata=function(t){"]"===t&&(this._state=z)},a.prototype._stateAfterCdata1=i("]",F),a.prototype._stateAfterCdata2=function(t){">"===t?(this._cbs.oncdata(this._buffer.substring(this._sectionStart,this._index-2)),this._state=p,this._sectionStart=this._index+1):"]"!==t&&(this._state=U)},a.prototype._stateBeforeSpecial=function(t){"c"===t||"C"===t?this._state=Y:"t"===t||"T"===t?this._state=et:(this._state=g,this._index--)},a.prototype._stateBeforeSpecialEnd=function(t){this._special!==bt||"c"!==t&&"C"!==t?this._special!==_t||"t"!==t&&"T"!==t?this._state=p:this._state=ot:this._state=Q},a.prototype._stateBeforeScript1=s("R",G),a.prototype._stateBeforeScript2=s("I",W),a.prototype._stateBeforeScript3=s("P",J),a.prototype._stateBeforeScript4=s("T",X),a.prototype._stateBeforeScript5=function(t){("/"===t||">"===t||n(t))&&(this._special=bt),this._state=g,this._index--},a.prototype._stateAfterScript1=o("R",Z,p),a.prototype._stateAfterScript2=o("I",K,p),a.prototype._stateAfterScript3=o("P",$,p),a.prototype._stateAfterScript4=o("T",tt,p),a.prototype._stateAfterScript5=function(t){">"===t||n(t)?(this._special=gt,this._state=m,this._sectionStart=this._index-6,this._index--):this._state=p},a.prototype._stateBeforeStyle1=s("Y",rt),a.prototype._stateBeforeStyle2=s("L",nt),a.prototype._stateBeforeStyle3=s("E",it),a.prototype._stateBeforeStyle4=function(t){("/"===t||">"===t||n(t))&&(this._special=_t),this._state=g,this._index--},a.prototype._stateAfterStyle1=o("Y",st,p),a.prototype._stateAfterStyle2=o("L",at,p),a.prototype._stateAfterStyle3=o("E",ct,p),a.prototype._stateAfterStyle4=function(t){">"===t||n(t)?(this._special=gt,this._state=m,this._sectionStart=this._index-5,this._index--):this._state=p},a.prototype._stateBeforeEntity=o("#",lt,ht),a.prototype._stateBeforeNumericEntity=o("X",pt,ft),a.prototype._parseNamedEntityStrict=function(){if(this._sectionStart+1<this._index){var t=this._buffer.substring(this._sectionStart+1,this._index),e=this._xmlMode?h:u;e.hasOwnProperty(t)&&(this._emitPartial(e[t]),this._sectionStart=this._index+1)}},a.prototype._parseLegacyEntity=function(){var t=this._sectionStart+1,e=this._index-t;for(e>6&&(e=6);e>=2;){var r=this._buffer.substr(t,e);if(l.hasOwnProperty(r))return this._emitPartial(l[r]),void(this._sectionStart+=e+1);e--}},a.prototype._stateInNamedEntity=function(t){";"===t?(this._parseNamedEntityStrict(),this._sectionStart+1<this._index&&!this._xmlMode&&this._parseLegacyEntity(),this._state=this._baseState):("a">t||t>"z")&&("A">t||t>"Z")&&("0">t||t>"9")&&(this._xmlMode||this._sectionStart+1===this._index||(this._baseState!==p?"="!==t&&this._parseNamedEntityStrict():this._parseLegacyEntity()),this._state=this._baseState,this._index--)},a.prototype._decodeNumericEntity=function(t,e){var r=this._sectionStart+t;if(r!==this._index){var n=this._buffer.substring(r,this._index),i=parseInt(n,e);this._emitPartial(c(i)),this._sectionStart=this._index}else this._sectionStart--;this._state=this._baseState},a.prototype._stateInNumericEntity=function(t){";"===t?(this._decodeNumericEntity(2,10),this._sectionStart++):("0">t||t>"9")&&(this._xmlMode?this._state=this._baseState:this._decodeNumericEntity(2,10),this._index--)},a.prototype._stateInHexEntity=function(t){";"===t?(this._decodeNumericEntity(3,16),this._sectionStart++):("a">t||t>"f")&&("A">t||t>"F")&&("0">t||t>"9")&&(this._xmlMode?this._state=this._baseState:this._decodeNumericEntity(3,16),this._index--)},a.prototype._cleanup=function(){this._sectionStart<0?(this._buffer="",this._index=0,this._bufferOffset+=this._index):this._running&&(this._state===p?(this._sectionStart!==this._index&&this._cbs.ontext(this._buffer.substr(this._sectionStart)),this._buffer="",this._index=0,this._bufferOffset+=this._index):this._sectionStart===this._index?(this._buffer="",this._index=0,this._bufferOffset+=this._index):(this._buffer=this._buffer.substr(this._sectionStart),this._index-=this._sectionStart,this._bufferOffset+=this._sectionStart),this._sectionStart=0)},a.prototype.write=function(t){this._ended&&this._cbs.onerror(Error(".write() after done!")),this._buffer+=t,this._parse()},a.prototype._parse=function(){for(;this._index<this._buffer.length&&this._running;){var t=this._buffer.charAt(this._index);this._state===p?this._stateText(t):this._state===d?this._stateBeforeTagName(t):this._state===g?this._stateInTagName(t):this._state===_?this._stateBeforeCloseingTagName(t):this._state===m?this._stateInCloseingTagName(t):this._state===y?this._stateAfterCloseingTagName(t):this._state===b?this._stateInSelfClosingTag(t):this._state===v?this._stateBeforeAttributeName(t):this._state===w?this._stateInAttributeName(t):this._state===x?this._stateAfterAttributeName(t):this._state===S?this._stateBeforeAttributeValue(t):this._state===E?this._stateInAttributeValueDoubleQuotes(t):this._state===A?this._stateInAttributeValueSingleQuotes(t):this._state===T?this._stateInAttributeValueNoQuotes(t):this._state===k?this._stateBeforeDeclaration(t):this._state===L?this._stateInDeclaration(t):this._state===O?this._stateInProcessingInstruction(t):this._state===I?this._stateBeforeComment(t):this._state===C?this._stateInComment(t):this._state===D?this._stateAfterComment1(t):this._state===B?this._stateAfterComment2(t):this._state===R?this._stateBeforeCdata1(t):this._state===q?this._stateBeforeCdata2(t):this._state===N?this._stateBeforeCdata3(t):this._state===j?this._stateBeforeCdata4(t):this._state===P?this._stateBeforeCdata5(t):this._state===M?this._stateBeforeCdata6(t):this._state===U?this._stateInCdata(t):this._state===z?this._stateAfterCdata1(t):this._state===F?this._stateAfterCdata2(t):this._state===H?this._stateBeforeSpecial(t):this._state===V?this._stateBeforeSpecialEnd(t):this._state===Y?this._stateBeforeScript1(t):this._state===G?this._stateBeforeScript2(t):this._state===W?this._stateBeforeScript3(t):this._state===J?this._stateBeforeScript4(t):this._state===X?this._stateBeforeScript5(t):this._state===Q?this._stateAfterScript1(t):this._state===Z?this._stateAfterScript2(t):this._state===K?this._stateAfterScript3(t):this._state===$?this._stateAfterScript4(t):this._state===tt?this._stateAfterScript5(t):this._state===et?this._stateBeforeStyle1(t):this._state===rt?this._stateBeforeStyle2(t):this._state===nt?this._stateBeforeStyle3(t):this._state===it?this._stateBeforeStyle4(t):this._state===ot?this._stateAfterStyle1(t):this._state===st?this._stateAfterStyle2(t):this._state===at?this._stateAfterStyle3(t):this._state===ct?this._stateAfterStyle4(t):this._state===ut?this._stateBeforeEntity(t):this._state===lt?this._stateBeforeNumericEntity(t):this._state===ht?this._stateInNamedEntity(t):this._state===ft?this._stateInNumericEntity(t):this._state===pt?this._stateInHexEntity(t):this._cbs.onerror(Error("unknown _state"),this._state),
+this._index++}this._cleanup()},a.prototype.pause=function(){this._running=!1},a.prototype.resume=function(){this._running=!0,this._index<this._buffer.length&&this._parse(),this._ended&&this._finish()},a.prototype.end=function(t){this._ended&&this._cbs.onerror(Error(".end() after done!")),t&&this.write(t),this._ended=!0,this._running&&this._finish()},a.prototype._finish=function(){this._sectionStart<this._index&&this._handleTrailingData(),this._cbs.onend()},a.prototype._handleTrailingData=function(){var t=this._buffer.substr(this._sectionStart);this._state===U||this._state===z||this._state===F?this._cbs.oncdata(t):this._state===C||this._state===D||this._state===B?this._cbs.oncomment(t):this._state!==ht||this._xmlMode?this._state!==ft||this._xmlMode?this._state!==pt||this._xmlMode?this._state!==g&&this._state!==v&&this._state!==S&&this._state!==x&&this._state!==w&&this._state!==A&&this._state!==E&&this._state!==T&&this._state!==m&&this._cbs.ontext(t):(this._decodeNumericEntity(3,16),this._sectionStart<this._index&&(this._state=this._baseState,this._handleTrailingData())):(this._decodeNumericEntity(2,10),this._sectionStart<this._index&&(this._state=this._baseState,this._handleTrailingData())):(this._parseLegacyEntity(),this._sectionStart<this._index&&(this._state=this._baseState,this._handleTrailingData()))},a.prototype.reset=function(){a.call(this,{xmlMode:this._xmlMode,decodeEntities:this._decodeEntities},this._cbs)},a.prototype.getAbsoluteIndex=function(){return this._bufferOffset+this._index},a.prototype._getSection=function(){return this._buffer.substring(this._sectionStart,this._index)},a.prototype._emitToken=function(t){this._cbs[t](this._getSection()),this._sectionStart=-1},a.prototype._emitPartial=function(t){this._baseState!==p?this._cbs.onattribdata(t):this._cbs.ontext(t)}},function(t,e,r){function n(t){if(t>=55296&&57343>=t||t>1114111)return"�";t in i&&(t=i[t]);var e="";return t>65535&&(t-=65536,e+=String.fromCharCode(t>>>10&1023|55296),t=56320|1023&t),e+=String.fromCharCode(t)}var i=r(12);t.exports=n},function(t,e){t.exports={0:65533,128:8364,130:8218,131:402,132:8222,133:8230,134:8224,135:8225,136:710,137:8240,138:352,139:8249,140:338,142:381,145:8216,146:8217,147:8220,148:8221,149:8226,150:8211,151:8212,152:732,153:8482,154:353,155:8250,156:339,158:382,159:376}},function(t,e){t.exports={Aacute:"Á",aacute:"á",Abreve:"Ă",abreve:"ă",ac:"∾",acd:"∿",acE:"∾̳",Acirc:"Â",acirc:"â",acute:"´",Acy:"А",acy:"а",AElig:"Æ",aelig:"æ",af:"⁡",Afr:"𝔄",afr:"𝔞",Agrave:"À",agrave:"à",alefsym:"ℵ",aleph:"ℵ",Alpha:"Α",alpha:"α",Amacr:"Ā",amacr:"ā",amalg:"⨿",amp:"&",AMP:"&",andand:"⩕",And:"⩓",and:"∧",andd:"⩜",andslope:"⩘",andv:"⩚",ang:"∠",ange:"⦤",angle:"∠",angmsdaa:"⦨",angmsdab:"⦩",angmsdac:"⦪",angmsdad:"⦫",angmsdae:"⦬",angmsdaf:"⦭",angmsdag:"⦮",angmsdah:"⦯",angmsd:"∡",angrt:"∟",angrtvb:"⊾",angrtvbd:"⦝",angsph:"∢",angst:"Å",angzarr:"⍼",Aogon:"Ą",aogon:"ą",Aopf:"𝔸",aopf:"𝕒",apacir:"⩯",ap:"≈",apE:"⩰",ape:"≊",apid:"≋",apos:"'",ApplyFunction:"⁡",approx:"≈",approxeq:"≊",Aring:"Å",aring:"å",Ascr:"𝒜",ascr:"𝒶",Assign:"≔",ast:"*",asymp:"≈",asympeq:"≍",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",awconint:"∳",awint:"⨑",backcong:"≌",backepsilon:"϶",backprime:"‵",backsim:"∽",backsimeq:"⋍",Backslash:"∖",Barv:"⫧",barvee:"⊽",barwed:"⌅",Barwed:"⌆",barwedge:"⌅",bbrk:"⎵",bbrktbrk:"⎶",bcong:"≌",Bcy:"Б",bcy:"б",bdquo:"„",becaus:"∵",because:"∵",Because:"∵",bemptyv:"⦰",bepsi:"϶",bernou:"ℬ",Bernoullis:"ℬ",Beta:"Β",beta:"β",beth:"ℶ",between:"≬",Bfr:"𝔅",bfr:"𝔟",bigcap:"⋂",bigcirc:"◯",bigcup:"⋃",bigodot:"⨀",bigoplus:"⨁",bigotimes:"⨂",bigsqcup:"⨆",bigstar:"★",bigtriangledown:"▽",bigtriangleup:"△",biguplus:"⨄",bigvee:"⋁",bigwedge:"⋀",bkarow:"⤍",blacklozenge:"⧫",blacksquare:"▪",blacktriangle:"▴",blacktriangledown:"▾",blacktriangleleft:"◂",blacktriangleright:"▸",blank:"␣",blk12:"▒",blk14:"░",blk34:"▓",block:"█",bne:"=⃥",bnequiv:"≡⃥",bNot:"⫭",bnot:"⌐",Bopf:"𝔹",bopf:"𝕓",bot:"⊥",bottom:"⊥",bowtie:"⋈",boxbox:"⧉",boxdl:"┐",boxdL:"╕",boxDl:"╖",boxDL:"╗",boxdr:"┌",boxdR:"╒",boxDr:"╓",boxDR:"╔",boxh:"─",boxH:"═",boxhd:"┬",boxHd:"╤",boxhD:"╥",boxHD:"╦",boxhu:"┴",boxHu:"╧",boxhU:"╨",boxHU:"╩",boxminus:"⊟",boxplus:"⊞",boxtimes:"⊠",boxul:"┘",boxuL:"╛",boxUl:"╜",boxUL:"╝",boxur:"└",boxuR:"╘",boxUr:"╙",boxUR:"╚",boxv:"│",boxV:"║",boxvh:"┼",boxvH:"╪",boxVh:"╫",boxVH:"╬",boxvl:"┤",boxvL:"╡",boxVl:"╢",boxVL:"╣",boxvr:"├",boxvR:"╞",boxVr:"╟",boxVR:"╠",bprime:"‵",breve:"˘",Breve:"˘",brvbar:"¦",bscr:"𝒷",Bscr:"ℬ",bsemi:"⁏",bsim:"∽",bsime:"⋍",bsolb:"⧅",bsol:"\\",bsolhsub:"⟈",bull:"•",bullet:"•",bump:"≎",bumpE:"⪮",bumpe:"≏",Bumpeq:"≎",bumpeq:"≏",Cacute:"Ć",cacute:"ć",capand:"⩄",capbrcup:"⩉",capcap:"⩋",cap:"∩",Cap:"⋒",capcup:"⩇",capdot:"⩀",CapitalDifferentialD:"ⅅ",caps:"∩︀",caret:"⁁",caron:"ˇ",Cayleys:"ℭ",ccaps:"⩍",Ccaron:"Č",ccaron:"č",Ccedil:"Ç",ccedil:"ç",Ccirc:"Ĉ",ccirc:"ĉ",Cconint:"∰",ccups:"⩌",ccupssm:"⩐",Cdot:"Ċ",cdot:"ċ",cedil:"¸",Cedilla:"¸",cemptyv:"⦲",cent:"¢",centerdot:"·",CenterDot:"·",cfr:"𝔠",Cfr:"ℭ",CHcy:"Ч",chcy:"ч",check:"✓",checkmark:"✓",Chi:"Χ",chi:"χ",circ:"ˆ",circeq:"≗",circlearrowleft:"↺",circlearrowright:"↻",circledast:"⊛",circledcirc:"⊚",circleddash:"⊝",CircleDot:"⊙",circledR:"®",circledS:"Ⓢ",CircleMinus:"⊖",CirclePlus:"⊕",CircleTimes:"⊗",cir:"○",cirE:"⧃",cire:"≗",cirfnint:"⨐",cirmid:"⫯",cirscir:"⧂",ClockwiseContourIntegral:"∲",CloseCurlyDoubleQuote:"”",CloseCurlyQuote:"’",clubs:"♣",clubsuit:"♣",colon:":",Colon:"∷",Colone:"⩴",colone:"≔",coloneq:"≔",comma:",",commat:"@",comp:"∁",compfn:"∘",complement:"∁",complexes:"ℂ",cong:"≅",congdot:"⩭",Congruent:"≡",conint:"∮",Conint:"∯",ContourIntegral:"∮",copf:"𝕔",Copf:"ℂ",coprod:"∐",Coproduct:"∐",copy:"©",COPY:"©",copysr:"℗",CounterClockwiseContourIntegral:"∳",crarr:"↵",cross:"✗",Cross:"⨯",Cscr:"𝒞",cscr:"𝒸",csub:"⫏",csube:"⫑",csup:"⫐",csupe:"⫒",ctdot:"⋯",cudarrl:"⤸",cudarrr:"⤵",cuepr:"⋞",cuesc:"⋟",cularr:"↶",cularrp:"⤽",cupbrcap:"⩈",cupcap:"⩆",CupCap:"≍",cup:"∪",Cup:"⋓",cupcup:"⩊",cupdot:"⊍",cupor:"⩅",cups:"∪︀",curarr:"↷",curarrm:"⤼",curlyeqprec:"⋞",curlyeqsucc:"⋟",curlyvee:"⋎",curlywedge:"⋏",curren:"¤",curvearrowleft:"↶",curvearrowright:"↷",cuvee:"⋎",cuwed:"⋏",cwconint:"∲",cwint:"∱",cylcty:"⌭",dagger:"†",Dagger:"‡",daleth:"ℸ",darr:"↓",Darr:"↡",dArr:"⇓",dash:"‐",Dashv:"⫤",dashv:"⊣",dbkarow:"⤏",dblac:"˝",Dcaron:"Ď",dcaron:"ď",Dcy:"Д",dcy:"д",ddagger:"‡",ddarr:"⇊",DD:"ⅅ",dd:"ⅆ",DDotrahd:"⤑",ddotseq:"⩷",deg:"°",Del:"∇",Delta:"Δ",delta:"δ",demptyv:"⦱",dfisht:"⥿",Dfr:"𝔇",dfr:"𝔡",dHar:"⥥",dharl:"⇃",dharr:"⇂",DiacriticalAcute:"´",DiacriticalDot:"˙",DiacriticalDoubleAcute:"˝",DiacriticalGrave:"`",DiacriticalTilde:"˜",diam:"⋄",diamond:"⋄",Diamond:"⋄",diamondsuit:"♦",diams:"♦",die:"¨",DifferentialD:"ⅆ",digamma:"ϝ",disin:"⋲",div:"÷",divide:"÷",divideontimes:"⋇",divonx:"⋇",DJcy:"Ђ",djcy:"ђ",dlcorn:"⌞",dlcrop:"⌍",dollar:"$",Dopf:"𝔻",dopf:"𝕕",Dot:"¨",dot:"˙",DotDot:"⃜",doteq:"≐",doteqdot:"≑",DotEqual:"≐",dotminus:"∸",dotplus:"∔",dotsquare:"⊡",doublebarwedge:"⌆",DoubleContourIntegral:"∯",DoubleDot:"¨",DoubleDownArrow:"⇓",DoubleLeftArrow:"⇐",DoubleLeftRightArrow:"⇔",DoubleLeftTee:"⫤",DoubleLongLeftArrow:"⟸",DoubleLongLeftRightArrow:"⟺",DoubleLongRightArrow:"⟹",DoubleRightArrow:"⇒",DoubleRightTee:"⊨",DoubleUpArrow:"⇑",DoubleUpDownArrow:"⇕",DoubleVerticalBar:"∥",DownArrowBar:"⤓",downarrow:"↓",DownArrow:"↓",Downarrow:"⇓",DownArrowUpArrow:"⇵",DownBreve:"̑",downdownarrows:"⇊",downharpoonleft:"⇃",downharpoonright:"⇂",DownLeftRightVector:"⥐",DownLeftTeeVector:"⥞",DownLeftVectorBar:"⥖",DownLeftVector:"↽",DownRightTeeVector:"⥟",DownRightVectorBar:"⥗",DownRightVector:"⇁",DownTeeArrow:"↧",DownTee:"⊤",drbkarow:"⤐",drcorn:"⌟",drcrop:"⌌",Dscr:"𝒟",dscr:"𝒹",DScy:"Ѕ",dscy:"ѕ",dsol:"⧶",Dstrok:"Đ",dstrok:"đ",dtdot:"⋱",dtri:"▿",dtrif:"▾",duarr:"⇵",duhar:"⥯",dwangle:"⦦",DZcy:"Џ",dzcy:"џ",dzigrarr:"⟿",Eacute:"É",eacute:"é",easter:"⩮",Ecaron:"Ě",ecaron:"ě",Ecirc:"Ê",ecirc:"ê",ecir:"≖",ecolon:"≕",Ecy:"Э",ecy:"э",eDDot:"⩷",Edot:"Ė",edot:"ė",eDot:"≑",ee:"ⅇ",efDot:"≒",Efr:"𝔈",efr:"𝔢",eg:"⪚",Egrave:"È",egrave:"è",egs:"⪖",egsdot:"⪘",el:"⪙",Element:"∈",elinters:"⏧",ell:"ℓ",els:"⪕",elsdot:"⪗",Emacr:"Ē",emacr:"ē",empty:"∅",emptyset:"∅",EmptySmallSquare:"◻",emptyv:"∅",EmptyVerySmallSquare:"▫",emsp13:" ",emsp14:" ",emsp:" ",ENG:"Ŋ",eng:"ŋ",ensp:" ",Eogon:"Ę",eogon:"ę",Eopf:"𝔼",eopf:"𝕖",epar:"⋕",eparsl:"⧣",eplus:"⩱",epsi:"ε",Epsilon:"Ε",epsilon:"ε",epsiv:"ϵ",eqcirc:"≖",eqcolon:"≕",eqsim:"≂",eqslantgtr:"⪖",eqslantless:"⪕",Equal:"⩵",equals:"=",EqualTilde:"≂",equest:"≟",Equilibrium:"⇌",equiv:"≡",equivDD:"⩸",eqvparsl:"⧥",erarr:"⥱",erDot:"≓",escr:"ℯ",Escr:"ℰ",esdot:"≐",Esim:"⩳",esim:"≂",Eta:"Η",eta:"η",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",euro:"€",excl:"!",exist:"∃",Exists:"∃",expectation:"ℰ",exponentiale:"ⅇ",ExponentialE:"ⅇ",fallingdotseq:"≒",Fcy:"Ф",fcy:"ф",female:"♀",ffilig:"ffi",fflig:"ff",ffllig:"ffl",Ffr:"𝔉",ffr:"𝔣",filig:"fi",FilledSmallSquare:"◼",FilledVerySmallSquare:"▪",fjlig:"fj",flat:"♭",fllig:"fl",fltns:"▱",fnof:"ƒ",Fopf:"𝔽",fopf:"𝕗",forall:"∀",ForAll:"∀",fork:"⋔",forkv:"⫙",Fouriertrf:"ℱ",fpartint:"⨍",frac12:"½",frac13:"⅓",frac14:"¼",frac15:"⅕",frac16:"⅙",frac18:"⅛",frac23:"⅔",frac25:"⅖",frac34:"¾",frac35:"⅗",frac38:"⅜",frac45:"⅘",frac56:"⅚",frac58:"⅝",frac78:"⅞",frasl:"⁄",frown:"⌢",fscr:"𝒻",Fscr:"ℱ",gacute:"ǵ",Gamma:"Γ",gamma:"γ",Gammad:"Ϝ",gammad:"ϝ",gap:"⪆",Gbreve:"Ğ",gbreve:"ğ",Gcedil:"Ģ",Gcirc:"Ĝ",gcirc:"ĝ",Gcy:"Г",gcy:"г",Gdot:"Ġ",gdot:"ġ",ge:"≥",gE:"≧",gEl:"⪌",gel:"⋛",geq:"≥",geqq:"≧",geqslant:"⩾",gescc:"⪩",ges:"⩾",gesdot:"⪀",gesdoto:"⪂",gesdotol:"⪄",gesl:"⋛︀",gesles:"⪔",Gfr:"𝔊",gfr:"𝔤",gg:"≫",Gg:"⋙",ggg:"⋙",gimel:"ℷ",GJcy:"Ѓ",gjcy:"ѓ",gla:"⪥",gl:"≷",glE:"⪒",glj:"⪤",gnap:"⪊",gnapprox:"⪊",gne:"⪈",gnE:"≩",gneq:"⪈",gneqq:"≩",gnsim:"⋧",Gopf:"𝔾",gopf:"𝕘",grave:"`",GreaterEqual:"≥",GreaterEqualLess:"⋛",GreaterFullEqual:"≧",GreaterGreater:"⪢",GreaterLess:"≷",GreaterSlantEqual:"⩾",GreaterTilde:"≳",Gscr:"𝒢",gscr:"ℊ",gsim:"≳",gsime:"⪎",gsiml:"⪐",gtcc:"⪧",gtcir:"⩺",gt:">",GT:">",Gt:"≫",gtdot:"⋗",gtlPar:"⦕",gtquest:"⩼",gtrapprox:"⪆",gtrarr:"⥸",gtrdot:"⋗",gtreqless:"⋛",gtreqqless:"⪌",gtrless:"≷",gtrsim:"≳",gvertneqq:"≩︀",gvnE:"≩︀",Hacek:"ˇ",hairsp:" ",half:"½",hamilt:"ℋ",HARDcy:"Ъ",hardcy:"ъ",harrcir:"⥈",harr:"↔",hArr:"⇔",harrw:"↭",Hat:"^",hbar:"ℏ",Hcirc:"Ĥ",hcirc:"ĥ",hearts:"♥",heartsuit:"♥",hellip:"…",hercon:"⊹",hfr:"𝔥",Hfr:"ℌ",HilbertSpace:"ℋ",hksearow:"⤥",hkswarow:"⤦",hoarr:"⇿",homtht:"∻",hookleftarrow:"↩",hookrightarrow:"↪",hopf:"𝕙",Hopf:"ℍ",horbar:"―",HorizontalLine:"─",hscr:"𝒽",Hscr:"ℋ",hslash:"ℏ",Hstrok:"Ħ",hstrok:"ħ",HumpDownHump:"≎",HumpEqual:"≏",hybull:"⁃",hyphen:"‐",Iacute:"Í",iacute:"í",ic:"⁣",Icirc:"Î",icirc:"î",Icy:"И",icy:"и",Idot:"İ",IEcy:"Е",iecy:"е",iexcl:"¡",iff:"⇔",ifr:"𝔦",Ifr:"ℑ",Igrave:"Ì",igrave:"ì",ii:"ⅈ",iiiint:"⨌",iiint:"∭",iinfin:"⧜",iiota:"℩",IJlig:"IJ",ijlig:"ij",Imacr:"Ī",imacr:"ī",image:"ℑ",ImaginaryI:"ⅈ",imagline:"ℐ",imagpart:"ℑ",imath:"ı",Im:"ℑ",imof:"⊷",imped:"Ƶ",Implies:"⇒",incare:"℅","in":"∈",infin:"∞",infintie:"⧝",inodot:"ı",intcal:"⊺","int":"∫",Int:"∬",integers:"ℤ",Integral:"∫",intercal:"⊺",Intersection:"⋂",intlarhk:"⨗",intprod:"⨼",InvisibleComma:"⁣",InvisibleTimes:"⁢",IOcy:"Ё",iocy:"ё",Iogon:"Į",iogon:"į",Iopf:"𝕀",iopf:"𝕚",Iota:"Ι",iota:"ι",iprod:"⨼",iquest:"¿",iscr:"𝒾",Iscr:"ℐ",isin:"∈",isindot:"⋵",isinE:"⋹",isins:"⋴",isinsv:"⋳",isinv:"∈",it:"⁢",Itilde:"Ĩ",itilde:"ĩ",Iukcy:"І",iukcy:"і",Iuml:"Ï",iuml:"ï",Jcirc:"Ĵ",jcirc:"ĵ",Jcy:"Й",jcy:"й",Jfr:"𝔍",jfr:"𝔧",jmath:"ȷ",Jopf:"𝕁",jopf:"𝕛",Jscr:"𝒥",jscr:"𝒿",Jsercy:"Ј",jsercy:"ј",Jukcy:"Є",jukcy:"є",Kappa:"Κ",kappa:"κ",kappav:"ϰ",Kcedil:"Ķ",kcedil:"ķ",Kcy:"К",kcy:"к",Kfr:"𝔎",kfr:"𝔨",kgreen:"ĸ",KHcy:"Х",khcy:"х",KJcy:"Ќ",kjcy:"ќ",Kopf:"𝕂",kopf:"𝕜",Kscr:"𝒦",kscr:"𝓀",lAarr:"⇚",Lacute:"Ĺ",lacute:"ĺ",laemptyv:"⦴",lagran:"ℒ",Lambda:"Λ",lambda:"λ",lang:"⟨",Lang:"⟪",langd:"⦑",langle:"⟨",lap:"⪅",Laplacetrf:"ℒ",laquo:"«",larrb:"⇤",larrbfs:"⤟",larr:"←",Larr:"↞",lArr:"⇐",larrfs:"⤝",larrhk:"↩",larrlp:"↫",larrpl:"⤹",larrsim:"⥳",larrtl:"↢",latail:"⤙",lAtail:"⤛",lat:"⪫",late:"⪭",lates:"⪭︀",lbarr:"⤌",lBarr:"⤎",lbbrk:"❲",lbrace:"{",lbrack:"[",lbrke:"⦋",lbrksld:"⦏",lbrkslu:"⦍",Lcaron:"Ľ",lcaron:"ľ",Lcedil:"Ļ",lcedil:"ļ",lceil:"⌈",lcub:"{",Lcy:"Л",lcy:"л",ldca:"⤶",ldquo:"“",ldquor:"„",ldrdhar:"⥧",ldrushar:"⥋",ldsh:"↲",le:"≤",lE:"≦",LeftAngleBracket:"⟨",LeftArrowBar:"⇤",leftarrow:"←",LeftArrow:"←",Leftarrow:"⇐",LeftArrowRightArrow:"⇆",leftarrowtail:"↢",LeftCeiling:"⌈",LeftDoubleBracket:"⟦",LeftDownTeeVector:"⥡",LeftDownVectorBar:"⥙",LeftDownVector:"⇃",LeftFloor:"⌊",leftharpoondown:"↽",leftharpoonup:"↼",leftleftarrows:"⇇",leftrightarrow:"↔",LeftRightArrow:"↔",Leftrightarrow:"⇔",leftrightarrows:"⇆",leftrightharpoons:"⇋",leftrightsquigarrow:"↭",LeftRightVector:"⥎",LeftTeeArrow:"↤",LeftTee:"⊣",LeftTeeVector:"⥚",leftthreetimes:"⋋",LeftTriangleBar:"⧏",LeftTriangle:"⊲",LeftTriangleEqual:"⊴",LeftUpDownVector:"⥑",LeftUpTeeVector:"⥠",LeftUpVectorBar:"⥘",LeftUpVector:"↿",LeftVectorBar:"⥒",LeftVector:"↼",lEg:"⪋",leg:"⋚",leq:"≤",leqq:"≦",leqslant:"⩽",lescc:"⪨",les:"⩽",lesdot:"⩿",lesdoto:"⪁",lesdotor:"⪃",lesg:"⋚︀",lesges:"⪓",lessapprox:"⪅",lessdot:"⋖",lesseqgtr:"⋚",lesseqqgtr:"⪋",LessEqualGreater:"⋚",LessFullEqual:"≦",LessGreater:"≶",lessgtr:"≶",LessLess:"⪡",lesssim:"≲",LessSlantEqual:"⩽",LessTilde:"≲",lfisht:"⥼",lfloor:"⌊",Lfr:"𝔏",lfr:"𝔩",lg:"≶",lgE:"⪑",lHar:"⥢",lhard:"↽",lharu:"↼",lharul:"⥪",lhblk:"▄",LJcy:"Љ",ljcy:"љ",llarr:"⇇",ll:"≪",Ll:"⋘",llcorner:"⌞",Lleftarrow:"⇚",llhard:"⥫",lltri:"◺",Lmidot:"Ŀ",lmidot:"ŀ",lmoustache:"⎰",lmoust:"⎰",lnap:"⪉",lnapprox:"⪉",lne:"⪇",lnE:"≨",lneq:"⪇",lneqq:"≨",lnsim:"⋦",loang:"⟬",loarr:"⇽",lobrk:"⟦",longleftarrow:"⟵",LongLeftArrow:"⟵",Longleftarrow:"⟸",longleftrightarrow:"⟷",LongLeftRightArrow:"⟷",Longleftrightarrow:"⟺",longmapsto:"⟼",longrightarrow:"⟶",LongRightArrow:"⟶",Longrightarrow:"⟹",looparrowleft:"↫",looparrowright:"↬",lopar:"⦅",Lopf:"𝕃",lopf:"𝕝",loplus:"⨭",lotimes:"⨴",lowast:"∗",lowbar:"_",LowerLeftArrow:"↙",LowerRightArrow:"↘",loz:"◊",lozenge:"◊",lozf:"⧫",lpar:"(",lparlt:"⦓",lrarr:"⇆",lrcorner:"⌟",lrhar:"⇋",lrhard:"⥭",lrm:"‎",lrtri:"⊿",lsaquo:"‹",lscr:"𝓁",Lscr:"ℒ",lsh:"↰",Lsh:"↰",lsim:"≲",lsime:"⪍",lsimg:"⪏",lsqb:"[",lsquo:"‘",lsquor:"‚",Lstrok:"Ł",lstrok:"ł",ltcc:"⪦",ltcir:"⩹",lt:"<",LT:"<",Lt:"≪",ltdot:"⋖",lthree:"⋋",ltimes:"⋉",ltlarr:"⥶",ltquest:"⩻",ltri:"◃",ltrie:"⊴",ltrif:"◂",ltrPar:"⦖",lurdshar:"⥊",luruhar:"⥦",lvertneqq:"≨︀",lvnE:"≨︀",macr:"¯",male:"♂",malt:"✠",maltese:"✠",Map:"⤅",map:"↦",mapsto:"↦",mapstodown:"↧",mapstoleft:"↤",mapstoup:"↥",marker:"▮",mcomma:"⨩",Mcy:"М",mcy:"м",mdash:"—",mDDot:"∺",measuredangle:"∡",MediumSpace:" ",Mellintrf:"ℳ",Mfr:"𝔐",mfr:"𝔪",mho:"℧",micro:"µ",midast:"*",midcir:"⫰",mid:"∣",middot:"·",minusb:"⊟",minus:"−",minusd:"∸",minusdu:"⨪",MinusPlus:"∓",mlcp:"⫛",mldr:"…",mnplus:"∓",models:"⊧",Mopf:"𝕄",mopf:"𝕞",mp:"∓",mscr:"𝓂",Mscr:"ℳ",mstpos:"∾",Mu:"Μ",mu:"μ",multimap:"⊸",mumap:"⊸",nabla:"∇",Nacute:"Ń",nacute:"ń",nang:"∠⃒",nap:"≉",napE:"⩰̸",napid:"≋̸",napos:"ʼn",napprox:"≉",natural:"♮",naturals:"ℕ",natur:"♮",nbsp:" ",nbump:"≎̸",nbumpe:"≏̸",ncap:"⩃",Ncaron:"Ň",ncaron:"ň",Ncedil:"Ņ",ncedil:"ņ",ncong:"≇",ncongdot:"⩭̸",ncup:"⩂",Ncy:"Н",ncy:"н",ndash:"–",nearhk:"⤤",nearr:"↗",neArr:"⇗",nearrow:"↗",ne:"≠",nedot:"≐̸",NegativeMediumSpace:"​",NegativeThickSpace:"​",NegativeThinSpace:"​",NegativeVeryThinSpace:"​",nequiv:"≢",nesear:"⤨",nesim:"≂̸",NestedGreaterGreater:"≫",NestedLessLess:"≪",NewLine:"\n",nexist:"∄",nexists:"∄",Nfr:"𝔑",nfr:"𝔫",ngE:"≧̸",nge:"≱",ngeq:"≱",ngeqq:"≧̸",ngeqslant:"⩾̸",nges:"⩾̸",nGg:"⋙̸",ngsim:"≵",nGt:"≫⃒",ngt:"≯",ngtr:"≯",nGtv:"≫̸",nharr:"↮",nhArr:"⇎",nhpar:"⫲",ni:"∋",nis:"⋼",nisd:"⋺",niv:"∋",NJcy:"Њ",njcy:"њ",nlarr:"↚",nlArr:"⇍",nldr:"‥",nlE:"≦̸",nle:"≰",nleftarrow:"↚",nLeftarrow:"⇍",nleftrightarrow:"↮",nLeftrightarrow:"⇎",nleq:"≰",nleqq:"≦̸",nleqslant:"⩽̸",nles:"⩽̸",nless:"≮",nLl:"⋘̸",nlsim:"≴",nLt:"≪⃒",nlt:"≮",nltri:"⋪",nltrie:"⋬",nLtv:"≪̸",nmid:"∤",NoBreak:"⁠",NonBreakingSpace:" ",nopf:"𝕟",Nopf:"ℕ",Not:"⫬",not:"¬",NotCongruent:"≢",NotCupCap:"≭",NotDoubleVerticalBar:"∦",NotElement:"∉",NotEqual:"≠",NotEqualTilde:"≂̸",NotExists:"∄",NotGreater:"≯",NotGreaterEqual:"≱",NotGreaterFullEqual:"≧̸",NotGreaterGreater:"≫̸",NotGreaterLess:"≹",NotGreaterSlantEqual:"⩾̸",NotGreaterTilde:"≵",NotHumpDownHump:"≎̸",NotHumpEqual:"≏̸",notin:"∉",notindot:"⋵̸",notinE:"⋹̸",notinva:"∉",notinvb:"⋷",notinvc:"⋶",NotLeftTriangleBar:"⧏̸",NotLeftTriangle:"⋪",NotLeftTriangleEqual:"⋬",NotLess:"≮",NotLessEqual:"≰",NotLessGreater:"≸",NotLessLess:"≪̸",NotLessSlantEqual:"⩽̸",NotLessTilde:"≴",NotNestedGreaterGreater:"⪢̸",NotNestedLessLess:"⪡̸",notni:"∌",notniva:"∌",notnivb:"⋾",notnivc:"⋽",NotPrecedes:"⊀",NotPrecedesEqual:"⪯̸",NotPrecedesSlantEqual:"⋠",NotReverseElement:"∌",NotRightTriangleBar:"⧐̸",NotRightTriangle:"⋫",NotRightTriangleEqual:"⋭",NotSquareSubset:"⊏̸",NotSquareSubsetEqual:"⋢",NotSquareSuperset:"⊐̸",NotSquareSupersetEqual:"⋣",NotSubset:"⊂⃒",NotSubsetEqual:"⊈",NotSucceeds:"⊁",NotSucceedsEqual:"⪰̸",NotSucceedsSlantEqual:"⋡",NotSucceedsTilde:"≿̸",NotSuperset:"⊃⃒",NotSupersetEqual:"⊉",NotTilde:"≁",NotTildeEqual:"≄",NotTildeFullEqual:"≇",NotTildeTilde:"≉",NotVerticalBar:"∤",nparallel:"∦",npar:"∦",nparsl:"⫽⃥",npart:"∂̸",npolint:"⨔",npr:"⊀",nprcue:"⋠",nprec:"⊀",npreceq:"⪯̸",npre:"⪯̸",nrarrc:"⤳̸",nrarr:"↛",nrArr:"⇏",nrarrw:"↝̸",nrightarrow:"↛",nRightarrow:"⇏",nrtri:"⋫",nrtrie:"⋭",nsc:"⊁",nsccue:"⋡",nsce:"⪰̸",Nscr:"𝒩",nscr:"𝓃",nshortmid:"∤",nshortparallel:"∦",nsim:"≁",nsime:"≄",nsimeq:"≄",nsmid:"∤",nspar:"∦",nsqsube:"⋢",nsqsupe:"⋣",nsub:"⊄",nsubE:"⫅̸",nsube:"⊈",nsubset:"⊂⃒",nsubseteq:"⊈",nsubseteqq:"⫅̸",nsucc:"⊁",nsucceq:"⪰̸",nsup:"⊅",nsupE:"⫆̸",nsupe:"⊉",nsupset:"⊃⃒",nsupseteq:"⊉",nsupseteqq:"⫆̸",ntgl:"≹",Ntilde:"Ñ",ntilde:"ñ",ntlg:"≸",ntriangleleft:"⋪",ntrianglelefteq:"⋬",ntriangleright:"⋫",ntrianglerighteq:"⋭",Nu:"Ν",nu:"ν",num:"#",numero:"№",numsp:" ",nvap:"≍⃒",nvdash:"⊬",nvDash:"⊭",nVdash:"⊮",nVDash:"⊯",nvge:"≥⃒",nvgt:">⃒",nvHarr:"⤄",nvinfin:"⧞",nvlArr:"⤂",nvle:"≤⃒",nvlt:"<⃒",nvltrie:"⊴⃒",nvrArr:"⤃",nvrtrie:"⊵⃒",nvsim:"∼⃒",nwarhk:"⤣",nwarr:"↖",nwArr:"⇖",nwarrow:"↖",nwnear:"⤧",Oacute:"Ó",oacute:"ó",oast:"⊛",Ocirc:"Ô",ocirc:"ô",ocir:"⊚",Ocy:"О",ocy:"о",odash:"⊝",Odblac:"Ő",odblac:"ő",odiv:"⨸",odot:"⊙",odsold:"⦼",OElig:"Œ",oelig:"œ",ofcir:"⦿",Ofr:"𝔒",ofr:"𝔬",ogon:"˛",Ograve:"Ò",ograve:"ò",ogt:"⧁",ohbar:"⦵",ohm:"Ω",oint:"∮",olarr:"↺",olcir:"⦾",olcross:"⦻",oline:"‾",olt:"⧀",Omacr:"Ō",omacr:"ō",Omega:"Ω",omega:"ω",Omicron:"Ο",omicron:"ο",omid:"⦶",ominus:"⊖",Oopf:"𝕆",oopf:"𝕠",opar:"⦷",OpenCurlyDoubleQuote:"“",OpenCurlyQuote:"‘",operp:"⦹",oplus:"⊕",orarr:"↻",Or:"⩔",or:"∨",ord:"⩝",order:"ℴ",orderof:"ℴ",ordf:"ª",ordm:"º",origof:"⊶",oror:"⩖",orslope:"⩗",orv:"⩛",oS:"Ⓢ",Oscr:"𝒪",oscr:"ℴ",Oslash:"Ø",oslash:"ø",osol:"⊘",Otilde:"Õ",otilde:"õ",otimesas:"⨶",Otimes:"⨷",otimes:"⊗",Ouml:"Ö",ouml:"ö",ovbar:"⌽",OverBar:"‾",OverBrace:"⏞",OverBracket:"⎴",OverParenthesis:"⏜",para:"¶",parallel:"∥",par:"∥",parsim:"⫳",parsl:"⫽",part:"∂",PartialD:"∂",Pcy:"П",pcy:"п",percnt:"%",period:".",permil:"‰",perp:"⊥",pertenk:"‱",Pfr:"𝔓",pfr:"𝔭",Phi:"Φ",phi:"φ",phiv:"ϕ",phmmat:"ℳ",phone:"☎",Pi:"Π",pi:"π",pitchfork:"⋔",piv:"ϖ",planck:"ℏ",planckh:"ℎ",plankv:"ℏ",plusacir:"⨣",plusb:"⊞",pluscir:"⨢",plus:"+",plusdo:"∔",plusdu:"⨥",pluse:"⩲",PlusMinus:"±",plusmn:"±",plussim:"⨦",plustwo:"⨧",pm:"±",Poincareplane:"ℌ",pointint:"⨕",popf:"𝕡",Popf:"ℙ",pound:"£",prap:"⪷",Pr:"⪻",pr:"≺",prcue:"≼",precapprox:"⪷",prec:"≺",preccurlyeq:"≼",Precedes:"≺",PrecedesEqual:"⪯",PrecedesSlantEqual:"≼",PrecedesTilde:"≾",preceq:"⪯",precnapprox:"⪹",precneqq:"⪵",precnsim:"⋨",pre:"⪯",prE:"⪳",precsim:"≾",prime:"′",Prime:"″",primes:"ℙ",prnap:"⪹",prnE:"⪵",prnsim:"⋨",prod:"∏",Product:"∏",profalar:"⌮",profline:"⌒",profsurf:"⌓",prop:"∝",Proportional:"∝",Proportion:"∷",propto:"∝",prsim:"≾",prurel:"⊰",Pscr:"𝒫",pscr:"𝓅",Psi:"Ψ",psi:"ψ",puncsp:" ",Qfr:"𝔔",qfr:"𝔮",qint:"⨌",qopf:"𝕢",Qopf:"ℚ",qprime:"⁗",Qscr:"𝒬",qscr:"𝓆",quaternions:"ℍ",quatint:"⨖",quest:"?",questeq:"≟",quot:'"',QUOT:'"',rAarr:"⇛",race:"∽̱",Racute:"Ŕ",racute:"ŕ",radic:"√",raemptyv:"⦳",rang:"⟩",Rang:"⟫",rangd:"⦒",range:"⦥",rangle:"⟩",raquo:"»",rarrap:"⥵",rarrb:"⇥",rarrbfs:"⤠",rarrc:"⤳",rarr:"→",Rarr:"↠",rArr:"⇒",rarrfs:"⤞",rarrhk:"↪",rarrlp:"↬",rarrpl:"⥅",rarrsim:"⥴",Rarrtl:"⤖",rarrtl:"↣",rarrw:"↝",ratail:"⤚",rAtail:"⤜",ratio:"∶",rationals:"ℚ",rbarr:"⤍",rBarr:"⤏",RBarr:"⤐",rbbrk:"❳",rbrace:"}",rbrack:"]",rbrke:"⦌",rbrksld:"⦎",rbrkslu:"⦐",Rcaron:"Ř",rcaron:"ř",Rcedil:"Ŗ",rcedil:"ŗ",rceil:"⌉",rcub:"}",Rcy:"Р",rcy:"р",rdca:"⤷",rdldhar:"⥩",rdquo:"”",rdquor:"”",rdsh:"↳",real:"ℜ",realine:"ℛ",realpart:"ℜ",reals:"ℝ",Re:"ℜ",rect:"▭",reg:"®",REG:"®",ReverseElement:"∋",ReverseEquilibrium:"⇋",ReverseUpEquilibrium:"⥯",rfisht:"⥽",rfloor:"⌋",rfr:"𝔯",Rfr:"ℜ",rHar:"⥤",rhard:"⇁",rharu:"⇀",rharul:"⥬",Rho:"Ρ",rho:"ρ",rhov:"ϱ",RightAngleBracket:"⟩",RightArrowBar:"⇥",rightarrow:"→",RightArrow:"→",Rightarrow:"⇒",RightArrowLeftArrow:"⇄",rightarrowtail:"↣",RightCeiling:"⌉",RightDoubleBracket:"⟧",RightDownTeeVector:"⥝",RightDownVectorBar:"⥕",RightDownVector:"⇂",RightFloor:"⌋",rightharpoondown:"⇁",rightharpoonup:"⇀",rightleftarrows:"⇄",rightleftharpoons:"⇌",rightrightarrows:"⇉",rightsquigarrow:"↝",RightTeeArrow:"↦",RightTee:"⊢",RightTeeVector:"⥛",rightthreetimes:"⋌",RightTriangleBar:"⧐",RightTriangle:"⊳",RightTriangleEqual:"⊵",RightUpDownVector:"⥏",RightUpTeeVector:"⥜",RightUpVectorBar:"⥔",RightUpVector:"↾",RightVectorBar:"⥓",RightVector:"⇀",ring:"˚",risingdotseq:"≓",rlarr:"⇄",rlhar:"⇌",rlm:"‏",rmoustache:"⎱",rmoust:"⎱",rnmid:"⫮",roang:"⟭",roarr:"⇾",robrk:"⟧",ropar:"⦆",ropf:"𝕣",Ropf:"ℝ",roplus:"⨮",rotimes:"⨵",RoundImplies:"⥰",rpar:")",rpargt:"⦔",rppolint:"⨒",rrarr:"⇉",Rrightarrow:"⇛",rsaquo:"›",rscr:"𝓇",Rscr:"ℛ",rsh:"↱",Rsh:"↱",rsqb:"]",rsquo:"’",rsquor:"’",rthree:"⋌",rtimes:"⋊",rtri:"▹",rtrie:"⊵",rtrif:"▸",rtriltri:"⧎",RuleDelayed:"⧴",ruluhar:"⥨",rx:"℞",Sacute:"Ś",sacute:"ś",sbquo:"‚",scap:"⪸",Scaron:"Š",scaron:"š",Sc:"⪼",sc:"≻",sccue:"≽",sce:"⪰",scE:"⪴",Scedil:"Ş",scedil:"ş",Scirc:"Ŝ",scirc:"ŝ",scnap:"⪺",scnE:"⪶",scnsim:"⋩",scpolint:"⨓",scsim:"≿",Scy:"С",scy:"с",sdotb:"⊡",sdot:"⋅",sdote:"⩦",searhk:"⤥",searr:"↘",seArr:"⇘",searrow:"↘",sect:"§",semi:";",seswar:"⤩",setminus:"∖",setmn:"∖",sext:"✶",Sfr:"𝔖",sfr:"𝔰",sfrown:"⌢",sharp:"♯",SHCHcy:"Щ",shchcy:"щ",SHcy:"Ш",shcy:"ш",ShortDownArrow:"↓",ShortLeftArrow:"←",shortmid:"∣",shortparallel:"∥",ShortRightArrow:"→",ShortUpArrow:"↑",shy:"­",Sigma:"Σ",sigma:"σ",sigmaf:"ς",sigmav:"ς",sim:"∼",simdot:"⩪",sime:"≃",simeq:"≃",simg:"⪞",simgE:"⪠",siml:"⪝",simlE:"⪟",simne:"≆",simplus:"⨤",simrarr:"⥲",slarr:"←",SmallCircle:"∘",smallsetminus:"∖",smashp:"⨳",smeparsl:"⧤",smid:"∣",smile:"⌣",smt:"⪪",smte:"⪬",smtes:"⪬︀",SOFTcy:"Ь",softcy:"ь",solbar:"⌿",solb:"⧄",sol:"/",Sopf:"𝕊",sopf:"𝕤",spades:"♠",spadesuit:"♠",spar:"∥",sqcap:"⊓",sqcaps:"⊓︀",sqcup:"⊔",sqcups:"⊔︀",Sqrt:"√",sqsub:"⊏",sqsube:"⊑",sqsubset:"⊏",sqsubseteq:"⊑",sqsup:"⊐",sqsupe:"⊒",sqsupset:"⊐",sqsupseteq:"⊒",square:"□",Square:"□",SquareIntersection:"⊓",SquareSubset:"⊏",SquareSubsetEqual:"⊑",SquareSuperset:"⊐",SquareSupersetEqual:"⊒",SquareUnion:"⊔",squarf:"▪",squ:"□",squf:"▪",srarr:"→",Sscr:"𝒮",sscr:"𝓈",ssetmn:"∖",ssmile:"⌣",sstarf:"⋆",Star:"⋆",star:"☆",starf:"★",straightepsilon:"ϵ",straightphi:"ϕ",strns:"¯",sub:"⊂",Sub:"⋐",subdot:"⪽",subE:"⫅",sube:"⊆",subedot:"⫃",submult:"⫁",subnE:"⫋",subne:"⊊",subplus:"⪿",subrarr:"⥹",subset:"⊂",Subset:"⋐",subseteq:"⊆",subseteqq:"⫅",SubsetEqual:"⊆",subsetneq:"⊊",subsetneqq:"⫋",subsim:"⫇",subsub:"⫕",subsup:"⫓",succapprox:"⪸",succ:"≻",succcurlyeq:"≽",Succeeds:"≻",SucceedsEqual:"⪰",SucceedsSlantEqual:"≽",SucceedsTilde:"≿",succeq:"⪰",succnapprox:"⪺",succneqq:"⪶",succnsim:"⋩",succsim:"≿",SuchThat:"∋",sum:"∑",Sum:"∑",sung:"♪",sup1:"¹",sup2:"²",sup3:"³",sup:"⊃",Sup:"⋑",supdot:"⪾",supdsub:"⫘",supE:"⫆",supe:"⊇",supedot:"⫄",Superset:"⊃",SupersetEqual:"⊇",suphsol:"⟉",suphsub:"⫗",suplarr:"⥻",supmult:"⫂",supnE:"⫌",supne:"⊋",supplus:"⫀",supset:"⊃",Supset:"⋑",supseteq:"⊇",supseteqq:"⫆",supsetneq:"⊋",supsetneqq:"⫌",supsim:"⫈",supsub:"⫔",supsup:"⫖",swarhk:"⤦",swarr:"↙",swArr:"⇙",swarrow:"↙",swnwar:"⤪",szlig:"ß",Tab:"	",target:"⌖",Tau:"Τ",tau:"τ",tbrk:"⎴",Tcaron:"Ť",tcaron:"ť",Tcedil:"Ţ",tcedil:"ţ",Tcy:"Т",tcy:"т",tdot:"⃛",telrec:"⌕",Tfr:"𝔗",tfr:"𝔱",there4:"∴",therefore:"∴",Therefore:"∴",Theta:"Θ",theta:"θ",thetasym:"ϑ",thetav:"ϑ",thickapprox:"≈",thicksim:"∼",ThickSpace:"  ",ThinSpace:" ",thinsp:" ",thkap:"≈",thksim:"∼",THORN:"Þ",thorn:"þ",tilde:"˜",Tilde:"∼",TildeEqual:"≃",TildeFullEqual:"≅",TildeTilde:"≈",timesbar:"⨱",timesb:"⊠",times:"×",timesd:"⨰",tint:"∭",toea:"⤨",topbot:"⌶",topcir:"⫱",top:"⊤",Topf:"𝕋",topf:"𝕥",topfork:"⫚",tosa:"⤩",tprime:"‴",trade:"™",TRADE:"™",triangle:"▵",triangledown:"▿",triangleleft:"◃",trianglelefteq:"⊴",triangleq:"≜",triangleright:"▹",trianglerighteq:"⊵",tridot:"◬",trie:"≜",triminus:"⨺",TripleDot:"⃛",triplus:"⨹",trisb:"⧍",tritime:"⨻",trpezium:"⏢",Tscr:"𝒯",tscr:"𝓉",TScy:"Ц",tscy:"ц",TSHcy:"Ћ",tshcy:"ћ",Tstrok:"Ŧ",tstrok:"ŧ",twixt:"≬",twoheadleftarrow:"↞",twoheadrightarrow:"↠",Uacute:"Ú",uacute:"ú",uarr:"↑",Uarr:"↟",uArr:"⇑",Uarrocir:"⥉",Ubrcy:"Ў",ubrcy:"ў",Ubreve:"Ŭ",ubreve:"ŭ",Ucirc:"Û",ucirc:"û",Ucy:"У",ucy:"у",udarr:"⇅",Udblac:"Ű",udblac:"ű",udhar:"⥮",ufisht:"⥾",Ufr:"𝔘",ufr:"𝔲",Ugrave:"Ù",ugrave:"ù",uHar:"⥣",uharl:"↿",uharr:"↾",uhblk:"▀",ulcorn:"⌜",ulcorner:"⌜",ulcrop:"⌏",ultri:"◸",Umacr:"Ū",umacr:"ū",uml:"¨",UnderBar:"_",UnderBrace:"⏟",UnderBracket:"⎵",UnderParenthesis:"⏝",Union:"⋃",UnionPlus:"⊎",Uogon:"Ų",uogon:"ų",Uopf:"𝕌",uopf:"𝕦",UpArrowBar:"⤒",uparrow:"↑",UpArrow:"↑",Uparrow:"⇑",UpArrowDownArrow:"⇅",updownarrow:"↕",UpDownArrow:"↕",Updownarrow:"⇕",UpEquilibrium:"⥮",upharpoonleft:"↿",upharpoonright:"↾",uplus:"⊎",UpperLeftArrow:"↖",UpperRightArrow:"↗",upsi:"υ",Upsi:"ϒ",upsih:"ϒ",Upsilon:"Υ",upsilon:"υ",UpTeeArrow:"↥",UpTee:"⊥",upuparrows:"⇈",urcorn:"⌝",urcorner:"⌝",urcrop:"⌎",Uring:"Ů",uring:"ů",urtri:"◹",Uscr:"𝒰",uscr:"𝓊",utdot:"⋰",Utilde:"Ũ",utilde:"ũ",utri:"▵",utrif:"▴",uuarr:"⇈",Uuml:"Ü",uuml:"ü",uwangle:"⦧",vangrt:"⦜",varepsilon:"ϵ",varkappa:"ϰ",varnothing:"∅",varphi:"ϕ",varpi:"ϖ",varpropto:"∝",varr:"↕",vArr:"⇕",varrho:"ϱ",varsigma:"ς",varsubsetneq:"⊊︀",varsubsetneqq:"⫋︀",varsupsetneq:"⊋︀",varsupsetneqq:"⫌︀",vartheta:"ϑ",vartriangleleft:"⊲",vartriangleright:"⊳",vBar:"⫨",Vbar:"⫫",vBarv:"⫩",Vcy:"В",vcy:"в",vdash:"⊢",vDash:"⊨",Vdash:"⊩",VDash:"⊫",Vdashl:"⫦",veebar:"⊻",vee:"∨",Vee:"⋁",veeeq:"≚",vellip:"⋮",verbar:"|",Verbar:"‖",vert:"|",Vert:"‖",VerticalBar:"∣",VerticalLine:"|",VerticalSeparator:"❘",VerticalTilde:"≀",VeryThinSpace:" ",Vfr:"𝔙",vfr:"𝔳",vltri:"⊲",vnsub:"⊂⃒",vnsup:"⊃⃒",Vopf:"𝕍",vopf:"𝕧",vprop:"∝",vrtri:"⊳",Vscr:"𝒱",vscr:"𝓋",vsubnE:"⫋︀",vsubne:"⊊︀",vsupnE:"⫌︀",vsupne:"⊋︀",Vvdash:"⊪",vzigzag:"⦚",Wcirc:"Ŵ",wcirc:"ŵ",wedbar:"⩟",wedge:"∧",Wedge:"⋀",wedgeq:"≙",weierp:"℘",Wfr:"𝔚",wfr:"𝔴",Wopf:"𝕎",wopf:"𝕨",wp:"℘",wr:"≀",wreath:"≀",Wscr:"𝒲",wscr:"𝓌",xcap:"⋂",xcirc:"◯",xcup:"⋃",xdtri:"▽",Xfr:"𝔛",xfr:"𝔵",xharr:"⟷",xhArr:"⟺",Xi:"Ξ",xi:"ξ",xlarr:"⟵",xlArr:"⟸",xmap:"⟼",xnis:"⋻",xodot:"⨀",Xopf:"𝕏",xopf:"𝕩",xoplus:"⨁",xotime:"⨂",xrarr:"⟶",xrArr:"⟹",Xscr:"𝒳",xscr:"𝓍",xsqcup:"⨆",xuplus:"⨄",xutri:"△",xvee:"⋁",xwedge:"⋀",Yacute:"Ý",yacute:"ý",YAcy:"Я",yacy:"я",Ycirc:"Ŷ",ycirc:"ŷ",Ycy:"Ы",ycy:"ы",yen:"¥",Yfr:"𝔜",yfr:"𝔶",YIcy:"Ї",yicy:"ї",Yopf:"𝕐",yopf:"𝕪",Yscr:"𝒴",yscr:"𝓎",YUcy:"Ю",yucy:"ю",yuml:"ÿ",Yuml:"Ÿ",Zacute:"Ź",zacute:"ź",Zcaron:"Ž",zcaron:"ž",Zcy:"З",zcy:"з",Zdot:"Ż",zdot:"ż",zeetrf:"ℨ",ZeroWidthSpace:"​",Zeta:"Ζ",zeta:"ζ",zfr:"𝔷",Zfr:"ℨ",ZHcy:"Ж",zhcy:"ж",zigrarr:"⇝",zopf:"𝕫",Zopf:"ℤ",Zscr:"𝒵",zscr:"𝓏",zwj:"‍",zwnj:"‌"}},function(t,e){t.exports={Aacute:"Á",aacute:"á",Acirc:"Â",acirc:"â",acute:"´",AElig:"Æ",aelig:"æ",Agrave:"À",agrave:"à",amp:"&",AMP:"&",Aring:"Å",aring:"å",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",brvbar:"¦",Ccedil:"Ç",ccedil:"ç",cedil:"¸",cent:"¢",copy:"©",COPY:"©",curren:"¤",deg:"°",divide:"÷",Eacute:"É",eacute:"é",Ecirc:"Ê",ecirc:"ê",Egrave:"È",egrave:"è",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",frac12:"½",frac14:"¼",frac34:"¾",gt:">",GT:">",Iacute:"Í",iacute:"í",Icirc:"Î",icirc:"î",iexcl:"¡",Igrave:"Ì",igrave:"ì",iquest:"¿",Iuml:"Ï",iuml:"ï",laquo:"«",lt:"<",LT:"<",macr:"¯",micro:"µ",middot:"·",nbsp:" ",not:"¬",Ntilde:"Ñ",ntilde:"ñ",Oacute:"Ó",oacute:"ó",Ocirc:"Ô",ocirc:"ô",Ograve:"Ò",ograve:"ò",ordf:"ª",ordm:"º",Oslash:"Ø",oslash:"ø",Otilde:"Õ",otilde:"õ",Ouml:"Ö",ouml:"ö",para:"¶",plusmn:"±",pound:"£",quot:'"',QUOT:'"',raquo:"»",reg:"®",REG:"®",sect:"§",shy:"­",sup1:"¹",sup2:"²",sup3:"³",szlig:"ß",THORN:"Þ",thorn:"þ",times:"×",Uacute:"Ú",uacute:"ú",Ucirc:"Û",ucirc:"û",Ugrave:"Ù",ugrave:"ù",uml:"¨",Uuml:"Ü",uuml:"ü",Yacute:"Ý",yacute:"ý",yen:"¥",yuml:"ÿ"}},function(t,e){t.exports={amp:"&",apos:"'",gt:">",lt:"<",quot:'"'}},function(t,e,r){function n(t,e,r){"object"==typeof t?(r=e,e=t,t=null):"function"==typeof e&&(r=e,e=c),this._callback=t,this._options=e||c,this._elementCB=r,this.dom=[],this._done=!1,this._tagStack=[],this._parser=this._parser||null}var i=r(17),o=/\s+/g,s=r(18),a=r(19),c={normalizeWhitespace:!1,withStartIndices:!1};n.prototype.onparserinit=function(t){this._parser=t},n.prototype.onreset=function(){n.call(this,this._callback,this._options,this._elementCB)},n.prototype.onend=function(){this._done||(this._done=!0,this._parser=null,this._handleCallback(null))},n.prototype._handleCallback=n.prototype.onerror=function(t){if("function"==typeof this._callback)this._callback(t,this.dom);else if(t)throw t},n.prototype.onclosetag=function(){var t=this._tagStack.pop();this._elementCB&&this._elementCB(t)},n.prototype._addDomElement=function(t){var e=this._tagStack[this._tagStack.length-1],r=e?e.children:this.dom,n=r[r.length-1];t.next=null,this._options.withStartIndices&&(t.startIndex=this._parser.startIndex),this._options.withDomLvl1&&(t.__proto__="tag"===t.type?a:s),n?(t.prev=n,n.next=t):t.prev=null,r.push(t),t.parent=e||null},n.prototype.onopentag=function(t,e){var r={type:"script"===t?i.Script:"style"===t?i.Style:i.Tag,name:t,attribs:e,children:[]};this._addDomElement(r),this._tagStack.push(r)},n.prototype.ontext=function(t){var e,r=this._options.normalizeWhitespace||this._options.ignoreWhitespace;!this._tagStack.length&&this.dom.length&&(e=this.dom[this.dom.length-1]).type===i.Text?r?e.data=(e.data+t).replace(o," "):e.data+=t:this._tagStack.length&&(e=this._tagStack[this._tagStack.length-1])&&(e=e.children[e.children.length-1])&&e.type===i.Text?r?e.data=(e.data+t).replace(o," "):e.data+=t:(r&&(t=t.replace(o," ")),this._addDomElement({data:t,type:i.Text}))},n.prototype.oncomment=function(t){var e=this._tagStack[this._tagStack.length-1];if(e&&e.type===i.Comment)return void(e.data+=t);var r={data:t,type:i.Comment};this._addDomElement(r),this._tagStack.push(r)},n.prototype.oncdatastart=function(){var t={children:[{data:"",type:i.Text}],type:i.CDATA};this._addDomElement(t),this._tagStack.push(t)},n.prototype.oncommentend=n.prototype.oncdataend=function(){this._tagStack.pop()},n.prototype.onprocessinginstruction=function(t,e){this._addDomElement({name:t,data:e,type:i.Directive})},t.exports=n},function(t,e){t.exports={Text:"text",Directive:"directive",Comment:"comment",Script:"script",Style:"style",Tag:"tag",CDATA:"cdata",Doctype:"doctype",isTag:function(t){return"tag"===t.type||"script"===t.type||"style"===t.type}}},function(t,e){var r=t.exports={get firstChild(){var t=this.children;return t&&t[0]||null},get lastChild(){var t=this.children;return t&&t[t.length-1]||null},get nodeType(){return i[this.type]||i.element}},n={tagName:"name",childNodes:"children",parentNode:"parent",previousSibling:"prev",nextSibling:"next",nodeValue:"data"},i={element:1,text:3,cdata:4,comment:8};Object.keys(n).forEach(function(t){var e=n[t];Object.defineProperty(r,t,{get:function(){return this[e]||null},set:function(t){return this[e]=t,t}})})},function(t,e,r){var n=r(18),i=t.exports=Object.create(n),o={tagName:"name"};Object.keys(o).forEach(function(t){var e=o[t];Object.defineProperty(i,t,{get:function(){return this[e]||null},set:function(t){return this[e]=t,t}})})},function(t,e,r){function n(t,e){this.init(t,e)}function i(t,e){return l.getElementsByTagName(t,e,!0)}function o(t,e){return l.getElementsByTagName(t,e,!0,1)[0]}function s(t,e,r){return l.getText(l.getElementsByTagName(t,e,r,1)).trim()}function a(t,e,r,n,i){var o=s(r,n,i);o&&(t[e]=o)}var c=r(8),u=c.DomHandler,l=c.DomUtils;r(2).inherits(n,u),n.prototype.init=u;var h=function(t){
+return"rss"===t||"feed"===t||"rdf:RDF"===t};n.prototype.onend=function(){var t,e,r={},n=o(h,this.dom);n&&("feed"===n.name?(e=n.children,r.type="atom",a(r,"id","id",e),a(r,"title","title",e),(t=o("link",e))&&(t=t.attribs)&&(t=t.href)&&(r.link=t),a(r,"description","subtitle",e),(t=s("updated",e))&&(r.updated=new Date(t)),a(r,"author","email",e,!0),r.items=i("entry",e).map(function(t){var e,r={};return t=t.children,a(r,"id","id",t),a(r,"title","title",t),(e=o("link",t))&&(e=e.attribs)&&(e=e.href)&&(r.link=e),(e=s("summary",t)||s("content",t))&&(r.description=e),(e=s("updated",t))&&(r.pubDate=new Date(e)),r})):(e=o("channel",n.children).children,r.type=n.name.substr(0,3),r.id="",a(r,"title","title",e),a(r,"link","link",e),a(r,"description","description",e),(t=s("lastBuildDate",e))&&(r.updated=new Date(t)),a(r,"author","managingEditor",e,!0),r.items=i("item",n.children).map(function(t){var e,r={};return t=t.children,a(r,"id","guid",t),a(r,"title","title",t),a(r,"link","link",t),a(r,"description","description",t),(e=s("pubDate",t))&&(r.pubDate=new Date(e)),r}))),this.dom=r,u.prototype._handleCallback.call(this,n?null:Error("couldn't find root of feed"))},t.exports=n},function(t,e,r){function n(t){o.call(this,new i(this),t)}function i(t){this.scope=t}t.exports=n;var o=r(22);r(2).inherits(n,o),n.prototype.readable=!0;var s=r(8).EVENTS;Object.keys(s).forEach(function(t){if(0===s[t])i.prototype["on"+t]=function(){this.scope.emit(t)};else if(1===s[t])i.prototype["on"+t]=function(e){this.scope.emit(t,e)};else{if(2!==s[t])throw Error("wrong number of arguments!");i.prototype["on"+t]=function(e,r){this.scope.emit(t,e,r)}}})},function(t,e,r){function n(t,e){var r=this._parser=new i(t,e);o.call(this,{decodeStrings:!1}),this.once("finish",function(){r.end()})}t.exports=n;var i=r(9),o=r(23).Writable||r(44).Writable;r(2).inherits(n,o),o.prototype._write=function(t,e,r){this._parser.write(t),r()}},function(t,e,r){function n(){i.call(this)}t.exports=n;var i=r(1).EventEmitter,o=r(24);o(n,i),n.Readable=r(25),n.Writable=r(40),n.Duplex=r(41),n.Transform=r(42),n.PassThrough=r(43),n.Stream=n,n.prototype.pipe=function(t,e){function r(e){t.writable&&!1===t.write(e)&&u.pause&&u.pause()}function n(){u.readable&&u.resume&&u.resume()}function o(){l||(l=!0,t.end())}function s(){l||(l=!0,"function"==typeof t.destroy&&t.destroy())}function a(t){if(c(),0===i.listenerCount(this,"error"))throw t}function c(){u.removeListener("data",r),t.removeListener("drain",n),u.removeListener("end",o),u.removeListener("close",s),u.removeListener("error",a),t.removeListener("error",a),u.removeListener("end",c),u.removeListener("close",c),t.removeListener("close",c)}var u=this;u.on("data",r),t.on("drain",n),t._isStdio||e&&e.end===!1||(u.on("end",o),u.on("close",s));var l=!1;return u.on("error",a),t.on("error",a),u.on("end",c),u.on("close",c),t.on("close",c),t.emit("pipe",u),t}},function(t,e){"function"==typeof Object.create?t.exports=function(t,e){t.super_=e,t.prototype=Object.create(e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(t,e){t.super_=e;var r=function(){};r.prototype=e.prototype,t.prototype=new r,t.prototype.constructor=t}},function(t,e,r){(function(n){e=t.exports=r(26),e.Stream=r(23),e.Readable=e,e.Writable=r(36),e.Duplex=r(35),e.Transform=r(38),e.PassThrough=r(39),n.browser||"disable"!==n.env.READABLE_STREAM||(t.exports=r(23))}).call(e,r(3))},function(t,e,r){(function(e){function n(t,e){var n=r(35);t=t||{};var i=t.highWaterMark,o=t.objectMode?16:16384;this.highWaterMark=i||0===i?i:o,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,e instanceof n&&(this.objectMode=this.objectMode||!!t.readableObjectMode),this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(L||(L=r(37).StringDecoder),this.decoder=new L(t.encoding),this.encoding=t.encoding)}function i(t){r(35);return this instanceof i?(this._readableState=new n(t,this),this.readable=!0,void T.call(this)):new i(t)}function o(t,e,r,n,i){var o=u(e,r);if(o)t.emit("error",o);else if(k.isNullOrUndefined(r))e.reading=!1,e.ended||l(t,e);else if(e.objectMode||r&&r.length>0)if(e.ended&&!i){var a=new Error("stream.push() after EOF");t.emit("error",a)}else if(e.endEmitted&&i){var a=new Error("stream.unshift() after end event");t.emit("error",a)}else!e.decoder||i||n||(r=e.decoder.write(r)),i||(e.reading=!1),e.flowing&&0===e.length&&!e.sync?(t.emit("data",r),t.read(0)):(e.length+=e.objectMode?1:r.length,i?e.buffer.unshift(r):e.buffer.push(r),e.needReadable&&h(t)),p(t,e);else i||(e.reading=!1);return s(e)}function s(t){return!t.ended&&(t.needReadable||t.length<t.highWaterMark||0===t.length)}function a(t){if(t>=I)t=I;else{t--;for(var e=1;32>e;e<<=1)t|=t>>e;t++}return t}function c(t,e){return 0===e.length&&e.ended?0:e.objectMode?0===t?0:1:isNaN(t)||k.isNull(t)?e.flowing&&e.buffer.length?e.buffer[0].length:e.length:0>=t?0:(t>e.highWaterMark&&(e.highWaterMark=a(t)),t>e.length?e.ended?e.length:(e.needReadable=!0,0):t)}function u(t,e){var r=null;return k.isBuffer(e)||k.isString(e)||k.isNullOrUndefined(e)||t.objectMode||(r=new TypeError("Invalid non-string/buffer chunk")),r}function l(t,e){if(e.decoder&&!e.ended){var r=e.decoder.end();r&&r.length&&(e.buffer.push(r),e.length+=e.objectMode?1:r.length)}e.ended=!0,h(t)}function h(t){var r=t._readableState;r.needReadable=!1,r.emittedReadable||(O("emitReadable",r.flowing),r.emittedReadable=!0,r.sync?e.nextTick(function(){f(t)}):f(t))}function f(t){O("emit readable"),t.emit("readable"),m(t)}function p(t,r){r.readingMore||(r.readingMore=!0,e.nextTick(function(){d(t,r)}))}function d(t,e){for(var r=e.length;!e.reading&&!e.flowing&&!e.ended&&e.length<e.highWaterMark&&(O("maybeReadMore read 0"),t.read(0),r!==e.length);)r=e.length;e.readingMore=!1}function g(t){return function(){var e=t._readableState;O("pipeOnDrain",e.awaitDrain),e.awaitDrain&&e.awaitDrain--,0===e.awaitDrain&&A.listenerCount(t,"data")&&(e.flowing=!0,m(t))}}function b(t,r){r.resumeScheduled||(r.resumeScheduled=!0,e.nextTick(function(){_(t,r)}))}function _(t,e){e.resumeScheduled=!1,t.emit("resume"),m(t),e.flowing&&!e.reading&&t.read(0)}function m(t){var e=t._readableState;if(O("flow",e.flowing),e.flowing)do var r=t.read();while(null!==r&&e.flowing)}function y(t,e){var r,n=e.buffer,i=e.length,o=!!e.decoder,s=!!e.objectMode;if(0===n.length)return null;if(0===i)r=null;else if(s)r=n.shift();else if(!t||t>=i)r=o?n.join(""):E.concat(n,i),n.length=0;else if(t<n[0].length){var a=n[0];r=a.slice(0,t),n[0]=a.slice(t)}else if(t===n[0].length)r=n.shift();else{r=o?"":new E(t);for(var c=0,u=0,l=n.length;l>u&&t>c;u++){var a=n[0],h=Math.min(t-c,a.length);o?r+=a.slice(0,h):a.copy(r,c,0,h),h<a.length?n[0]=a.slice(h):n.shift(),c+=h}}return r}function v(t){var r=t._readableState;if(r.length>0)throw new Error("endReadable called on non-empty stream");r.endEmitted||(r.ended=!0,e.nextTick(function(){r.endEmitted||0!==r.length||(r.endEmitted=!0,t.readable=!1,t.emit("end"))}))}function w(t,e){for(var r=0,n=t.length;n>r;r++)e(t[r],r)}function x(t,e){for(var r=0,n=t.length;n>r;r++)if(t[r]===e)return r;return-1}t.exports=i;var S=r(27),E=r(28).Buffer;i.ReadableState=n;var A=r(1).EventEmitter;A.listenerCount||(A.listenerCount=function(t,e){return t.listeners(e).length});var T=r(23),k=r(32);k.inherits=r(33);var L,O=r(34);O=O&&O.debuglog?O.debuglog("stream"):function(){},k.inherits(i,T),i.prototype.push=function(t,e){var r=this._readableState;return k.isString(t)&&!r.objectMode&&(e=e||r.defaultEncoding,e!==r.encoding&&(t=new E(t,e),e="")),o(this,r,t,e,!1)},i.prototype.unshift=function(t){var e=this._readableState;return o(this,e,t,"",!0)},i.prototype.setEncoding=function(t){return L||(L=r(37).StringDecoder),this._readableState.decoder=new L(t),this._readableState.encoding=t,this};var I=8388608;i.prototype.read=function(t){O("read",t);var e=this._readableState,r=t;if((!k.isNumber(t)||t>0)&&(e.emittedReadable=!1),0===t&&e.needReadable&&(e.length>=e.highWaterMark||e.ended))return O("read: emitReadable",e.length,e.ended),0===e.length&&e.ended?v(this):h(this),null;if(t=c(t,e),0===t&&e.ended)return 0===e.length&&v(this),null;var n=e.needReadable;O("need readable",n),(0===e.length||e.length-t<e.highWaterMark)&&(n=!0,O("length less than watermark",n)),(e.ended||e.reading)&&(n=!1,O("reading or ended",n)),n&&(O("do read"),e.reading=!0,e.sync=!0,0===e.length&&(e.needReadable=!0),this._read(e.highWaterMark),e.sync=!1),n&&!e.reading&&(t=c(r,e));var i;return i=t>0?y(t,e):null,k.isNull(i)&&(e.needReadable=!0,t=0),e.length-=t,0!==e.length||e.ended||(e.needReadable=!0),r!==t&&e.ended&&0===e.length&&v(this),k.isNull(i)||this.emit("data",i),i},i.prototype._read=function(t){this.emit("error",new Error("not implemented"))},i.prototype.pipe=function(t,r){function n(t){O("onunpipe"),t===h&&o()}function i(){O("onend"),t.end()}function o(){O("cleanup"),t.removeListener("close",c),t.removeListener("finish",u),t.removeListener("drain",b),t.removeListener("error",a),t.removeListener("unpipe",n),h.removeListener("end",i),h.removeListener("end",o),h.removeListener("data",s),!f.awaitDrain||t._writableState&&!t._writableState.needDrain||b()}function s(e){O("ondata");var r=t.write(e);!1===r&&(O("false write response, pause",h._readableState.awaitDrain),h._readableState.awaitDrain++,h.pause())}function a(e){O("onerror",e),l(),t.removeListener("error",a),0===A.listenerCount(t,"error")&&t.emit("error",e)}function c(){t.removeListener("finish",u),l()}function u(){O("onfinish"),t.removeListener("close",c),l()}function l(){O("unpipe"),h.unpipe(t)}var h=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=t;break;case 1:f.pipes=[f.pipes,t];break;default:f.pipes.push(t)}f.pipesCount+=1,O("pipe count=%d opts=%j",f.pipesCount,r);var p=(!r||r.end!==!1)&&t!==e.stdout&&t!==e.stderr,d=p?i:o;f.endEmitted?e.nextTick(d):h.once("end",d),t.on("unpipe",n);var b=g(h);return t.on("drain",b),h.on("data",s),t._events&&t._events.error?S(t._events.error)?t._events.error.unshift(a):t._events.error=[a,t._events.error]:t.on("error",a),t.once("close",c),t.once("finish",u),t.emit("pipe",h),f.flowing||(O("pipe resume"),h.resume()),t},i.prototype.unpipe=function(t){var e=this._readableState;if(0===e.pipesCount)return this;if(1===e.pipesCount)return t&&t!==e.pipes?this:(t||(t=e.pipes),e.pipes=null,e.pipesCount=0,e.flowing=!1,t&&t.emit("unpipe",this),this);if(!t){var r=e.pipes,n=e.pipesCount;e.pipes=null,e.pipesCount=0,e.flowing=!1;for(var i=0;n>i;i++)r[i].emit("unpipe",this);return this}var i=x(e.pipes,t);return-1===i?this:(e.pipes.splice(i,1),e.pipesCount-=1,1===e.pipesCount&&(e.pipes=e.pipes[0]),t.emit("unpipe",this),this)},i.prototype.on=function(t,r){var n=T.prototype.on.call(this,t,r);if("data"===t&&!1!==this._readableState.flowing&&this.resume(),"readable"===t&&this.readable){var i=this._readableState;if(!i.readableListening)if(i.readableListening=!0,i.emittedReadable=!1,i.needReadable=!0,i.reading)i.length&&h(this,i);else{var o=this;e.nextTick(function(){O("readable nexttick read 0"),o.read(0)})}}return n},i.prototype.addListener=i.prototype.on,i.prototype.resume=function(){var t=this._readableState;return t.flowing||(O("resume"),t.flowing=!0,t.reading||(O("resume read 0"),this.read(0)),b(this,t)),this},i.prototype.pause=function(){return O("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(O("pause"),this._readableState.flowing=!1,this.emit("pause")),this},i.prototype.wrap=function(t){var e=this._readableState,r=!1,n=this;t.on("end",function(){if(O("wrapped end"),e.decoder&&!e.ended){var t=e.decoder.end();t&&t.length&&n.push(t)}n.push(null)}),t.on("data",function(i){if(O("wrapped data"),e.decoder&&(i=e.decoder.write(i)),i&&(e.objectMode||i.length)){var o=n.push(i);o||(r=!0,t.pause())}});for(var i in t)k.isFunction(t[i])&&k.isUndefined(this[i])&&(this[i]=function(e){return function(){return t[e].apply(t,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return w(o,function(e){t.on(e,n.emit.bind(n,e))}),n._read=function(e){O("wrapped _read",e),r&&(r=!1,t.resume())},n},i._fromList=y}).call(e,r(3))},function(t,e){t.exports=Array.isArray||function(t){return"[object Array]"==Object.prototype.toString.call(t)}},function(t,e,r){(function(t,n){/*!
+	 * The buffer module from node.js, for the browser.
+	 *
+	 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+	 * @license  MIT
+	 */
+"use strict";function i(){function t(){}try{var e=new Uint8Array(1);return e.foo=function(){return 42},e.constructor=t,42===e.foo()&&e.constructor===t&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(r){return!1}}function o(){return t.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function t(e){return this instanceof t?(t.TYPED_ARRAY_SUPPORT||(this.length=0,this.parent=void 0),"number"==typeof e?s(this,e):"string"==typeof e?a(this,e,arguments.length>1?arguments[1]:"utf8"):c(this,e)):arguments.length>1?new t(e,arguments[1]):new t(e)}function s(e,r){if(e=g(e,0>r?0:0|b(r)),!t.TYPED_ARRAY_SUPPORT)for(var n=0;r>n;n++)e[n]=0;return e}function a(t,e,r){"string"==typeof r&&""!==r||(r="utf8");var n=0|m(e,r);return t=g(t,n),t.write(e,r),t}function c(e,r){if(t.isBuffer(r))return u(e,r);if(Q(r))return l(e,r);if(null==r)throw new TypeError("must start with number, buffer, array or string");if("undefined"!=typeof ArrayBuffer){if(r.buffer instanceof ArrayBuffer)return h(e,r);if(r instanceof ArrayBuffer)return f(e,r)}return r.length?p(e,r):d(e,r)}function u(t,e){var r=0|b(e.length);return t=g(t,r),e.copy(t,0,0,r),t}function l(t,e){var r=0|b(e.length);t=g(t,r);for(var n=0;r>n;n+=1)t[n]=255&e[n];return t}function h(t,e){var r=0|b(e.length);t=g(t,r);for(var n=0;r>n;n+=1)t[n]=255&e[n];return t}function f(e,r){return t.TYPED_ARRAY_SUPPORT?(r.byteLength,e=t._augment(new Uint8Array(r))):e=h(e,new Uint8Array(r)),e}function p(t,e){var r=0|b(e.length);t=g(t,r);for(var n=0;r>n;n+=1)t[n]=255&e[n];return t}function d(t,e){var r,n=0;"Buffer"===e.type&&Q(e.data)&&(r=e.data,n=0|b(r.length)),t=g(t,n);for(var i=0;n>i;i+=1)t[i]=255&r[i];return t}function g(e,r){t.TYPED_ARRAY_SUPPORT?(e=t._augment(new Uint8Array(r)),e.__proto__=t.prototype):(e.length=r,e._isBuffer=!0);var n=0!==r&&r<=t.poolSize>>>1;return n&&(e.parent=Z),e}function b(t){if(t>=o())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+o().toString(16)+" bytes");return 0|t}function _(e,r){if(!(this instanceof _))return new _(e,r);var n=new t(e,r);return delete n.parent,n}function m(t,e){"string"!=typeof t&&(t=""+t);var r=t.length;if(0===r)return 0;for(var n=!1;;)switch(e){case"ascii":case"binary":case"raw":case"raws":return r;case"utf8":case"utf-8":return H(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return G(t).length;default:if(n)return H(t).length;e=(""+e).toLowerCase(),n=!0}}function y(t,e,r){var n=!1;if(e=0|e,r=void 0===r||r===1/0?this.length:0|r,t||(t="utf8"),0>e&&(e=0),r>this.length&&(r=this.length),e>=r)return"";for(;;)switch(t){case"hex":return C(this,e,r);case"utf8":case"utf-8":return k(this,e,r);case"ascii":return O(this,e,r);case"binary":return I(this,e,r);case"base64":return T(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return D(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}function v(t,e,r,n){r=Number(r)||0;var i=t.length-r;n?(n=Number(n),n>i&&(n=i)):n=i;var o=e.length;if(o%2!==0)throw new Error("Invalid hex string");n>o/2&&(n=o/2);for(var s=0;n>s;s++){var a=parseInt(e.substr(2*s,2),16);if(isNaN(a))throw new Error("Invalid hex string");t[r+s]=a}return s}function w(t,e,r,n){return W(H(e,t.length-r),t,r,n)}function x(t,e,r,n){return W(V(e),t,r,n)}function S(t,e,r,n){return x(t,e,r,n)}function E(t,e,r,n){return W(G(e),t,r,n)}function A(t,e,r,n){return W(Y(e,t.length-r),t,r,n)}function T(t,e,r){return 0===e&&r===t.length?J.fromByteArray(t):J.fromByteArray(t.slice(e,r))}function k(t,e,r){r=Math.min(t.length,r);for(var n=[],i=e;r>i;){var o=t[i],s=null,a=o>239?4:o>223?3:o>191?2:1;if(r>=i+a){var c,u,l,h;switch(a){case 1:128>o&&(s=o);break;case 2:c=t[i+1],128===(192&c)&&(h=(31&o)<<6|63&c,h>127&&(s=h));break;case 3:c=t[i+1],u=t[i+2],128===(192&c)&&128===(192&u)&&(h=(15&o)<<12|(63&c)<<6|63&u,h>2047&&(55296>h||h>57343)&&(s=h));break;case 4:c=t[i+1],u=t[i+2],l=t[i+3],128===(192&c)&&128===(192&u)&&128===(192&l)&&(h=(15&o)<<18|(63&c)<<12|(63&u)<<6|63&l,h>65535&&1114112>h&&(s=h))}}null===s?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|1023&s),n.push(s),i+=a}return L(n)}function L(t){var e=t.length;if(K>=e)return String.fromCharCode.apply(String,t);for(var r="",n=0;e>n;)r+=String.fromCharCode.apply(String,t.slice(n,n+=K));return r}function O(t,e,r){var n="";r=Math.min(t.length,r);for(var i=e;r>i;i++)n+=String.fromCharCode(127&t[i]);return n}function I(t,e,r){var n="";r=Math.min(t.length,r);for(var i=e;r>i;i++)n+=String.fromCharCode(t[i]);return n}function C(t,e,r){var n=t.length;(!e||0>e)&&(e=0),(!r||0>r||r>n)&&(r=n);for(var i="",o=e;r>o;o++)i+=F(t[o]);return i}function D(t,e,r){for(var n=t.slice(e,r),i="",o=0;o<n.length;o+=2)i+=String.fromCharCode(n[o]+256*n[o+1]);return i}function B(t,e,r){if(t%1!==0||0>t)throw new RangeError("offset is not uint");if(t+e>r)throw new RangeError("Trying to access beyond buffer length")}function R(e,r,n,i,o,s){if(!t.isBuffer(e))throw new TypeError("buffer must be a Buffer instance");if(r>o||s>r)throw new RangeError("value is out of bounds");if(n+i>e.length)throw new RangeError("index out of range")}function q(t,e,r,n){0>e&&(e=65535+e+1);for(var i=0,o=Math.min(t.length-r,2);o>i;i++)t[r+i]=(e&255<<8*(n?i:1-i))>>>8*(n?i:1-i)}function N(t,e,r,n){0>e&&(e=4294967295+e+1);for(var i=0,o=Math.min(t.length-r,4);o>i;i++)t[r+i]=e>>>8*(n?i:3-i)&255}function j(t,e,r,n,i,o){if(e>i||o>e)throw new RangeError("value is out of bounds");if(r+n>t.length)throw new RangeError("index out of range");if(0>r)throw new RangeError("index out of range")}function P(t,e,r,n,i){return i||j(t,e,r,4,3.4028234663852886e38,-3.4028234663852886e38),X.write(t,e,r,n,23,4),r+4}function M(t,e,r,n,i){return i||j(t,e,r,8,1.7976931348623157e308,-1.7976931348623157e308),X.write(t,e,r,n,52,8),r+8}function U(t){if(t=z(t).replace(tt,""),t.length<2)return"";for(;t.length%4!==0;)t+="=";return t}function z(t){return t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")}function F(t){return 16>t?"0"+t.toString(16):t.toString(16)}function H(t,e){e=e||1/0;for(var r,n=t.length,i=null,o=[],s=0;n>s;s++){if(r=t.charCodeAt(s),r>55295&&57344>r){if(!i){if(r>56319){(e-=3)>-1&&o.push(239,191,189);continue}if(s+1===n){(e-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(56320>r){(e-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(e-=3)>-1&&o.push(239,191,189);if(i=null,128>r){if((e-=1)<0)break;o.push(r)}else if(2048>r){if((e-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(65536>r){if((e-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(1114112>r))throw new Error("Invalid code point");if((e-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function V(t){for(var e=[],r=0;r<t.length;r++)e.push(255&t.charCodeAt(r));return e}function Y(t,e){for(var r,n,i,o=[],s=0;s<t.length&&!((e-=2)<0);s++)r=t.charCodeAt(s),n=r>>8,i=r%256,o.push(i),o.push(n);return o}function G(t){return J.toByteArray(U(t))}function W(t,e,r,n){for(var i=0;n>i&&!(i+r>=e.length||i>=t.length);i++)e[i+r]=t[i];return i}var J=r(29),X=r(30),Q=r(31);e.Buffer=t,e.SlowBuffer=_,e.INSPECT_MAX_BYTES=50,t.poolSize=8192;var Z={};t.TYPED_ARRAY_SUPPORT=void 0!==n.TYPED_ARRAY_SUPPORT?n.TYPED_ARRAY_SUPPORT:i(),t.TYPED_ARRAY_SUPPORT?(t.prototype.__proto__=Uint8Array.prototype,t.__proto__=Uint8Array):(t.prototype.length=void 0,t.prototype.parent=void 0),t.isBuffer=function(t){return!(null==t||!t._isBuffer)},t.compare=function(e,r){if(!t.isBuffer(e)||!t.isBuffer(r))throw new TypeError("Arguments must be Buffers");if(e===r)return 0;for(var n=e.length,i=r.length,o=0,s=Math.min(n,i);s>o&&e[o]===r[o];)++o;return o!==s&&(n=e[o],i=r[o]),i>n?-1:n>i?1:0},t.isEncoding=function(t){switch(String(t).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},t.concat=function(e,r){if(!Q(e))throw new TypeError("list argument must be an Array of Buffers.");if(0===e.length)return new t(0);var n;if(void 0===r)for(r=0,n=0;n<e.length;n++)r+=e[n].length;var i=new t(r),o=0;for(n=0;n<e.length;n++){var s=e[n];s.copy(i,o),o+=s.length}return i},t.byteLength=m,t.prototype.toString=function(){var t=0|this.length;return 0===t?"":0===arguments.length?k(this,0,t):y.apply(this,arguments)},t.prototype.equals=function(e){if(!t.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e?!0:0===t.compare(this,e)},t.prototype.inspect=function(){var t="",r=e.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString("hex",0,r).match(/.{2}/g).join(" "),this.length>r&&(t+=" ... ")),"<Buffer "+t+">"},t.prototype.compare=function(e){if(!t.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e?0:t.compare(this,e)},t.prototype.indexOf=function(e,r){function n(t,e,r){for(var n=-1,i=0;r+i<t.length;i++)if(t[r+i]===e[-1===n?0:i-n]){if(-1===n&&(n=i),i-n+1===e.length)return r+n}else n=-1;return-1}if(r>2147483647?r=2147483647:-2147483648>r&&(r=-2147483648),r>>=0,0===this.length)return-1;if(r>=this.length)return-1;if(0>r&&(r=Math.max(this.length+r,0)),"string"==typeof e)return 0===e.length?-1:String.prototype.indexOf.call(this,e,r);if(t.isBuffer(e))return n(this,e,r);if("number"==typeof e)return t.TYPED_ARRAY_SUPPORT&&"function"===Uint8Array.prototype.indexOf?Uint8Array.prototype.indexOf.call(this,e,r):n(this,[e],r);throw new TypeError("val must be string, number or Buffer")},t.prototype.get=function(t){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(t)},t.prototype.set=function(t,e){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(t,e)},t.prototype.write=function(t,e,r,n){if(void 0===e)n="utf8",r=this.length,e=0;else if(void 0===r&&"string"==typeof e)n=e,r=this.length,e=0;else if(isFinite(e))e=0|e,isFinite(r)?(r=0|r,void 0===n&&(n="utf8")):(n=r,r=void 0);else{var i=n;n=e,e=0|r,r=i}var o=this.length-e;if((void 0===r||r>o)&&(r=o),t.length>0&&(0>r||0>e)||e>this.length)throw new RangeError("attempt to write outside buffer bounds");n||(n="utf8");for(var s=!1;;)switch(n){case"hex":return v(this,t,e,r);case"utf8":case"utf-8":return w(this,t,e,r);case"ascii":return x(this,t,e,r);case"binary":return S(this,t,e,r);case"base64":return E(this,t,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return A(this,t,e,r);default:if(s)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),s=!0}},t.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var K=4096;t.prototype.slice=function(e,r){var n=this.length;e=~~e,r=void 0===r?n:~~r,0>e?(e+=n,0>e&&(e=0)):e>n&&(e=n),0>r?(r+=n,0>r&&(r=0)):r>n&&(r=n),e>r&&(r=e);var i;if(t.TYPED_ARRAY_SUPPORT)i=t._augment(this.subarray(e,r));else{var o=r-e;i=new t(o,void 0);for(var s=0;o>s;s++)i[s]=this[s+e]}return i.length&&(i.parent=this.parent||this),i},t.prototype.readUIntLE=function(t,e,r){t=0|t,e=0|e,r||B(t,e,this.length);for(var n=this[t],i=1,o=0;++o<e&&(i*=256);)n+=this[t+o]*i;return n},t.prototype.readUIntBE=function(t,e,r){t=0|t,e=0|e,r||B(t,e,this.length);for(var n=this[t+--e],i=1;e>0&&(i*=256);)n+=this[t+--e]*i;return n},t.prototype.readUInt8=function(t,e){return e||B(t,1,this.length),this[t]},t.prototype.readUInt16LE=function(t,e){return e||B(t,2,this.length),this[t]|this[t+1]<<8},t.prototype.readUInt16BE=function(t,e){return e||B(t,2,this.length),this[t]<<8|this[t+1]},t.prototype.readUInt32LE=function(t,e){return e||B(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},t.prototype.readUInt32BE=function(t,e){return e||B(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},t.prototype.readIntLE=function(t,e,r){t=0|t,e=0|e,r||B(t,e,this.length);for(var n=this[t],i=1,o=0;++o<e&&(i*=256);)n+=this[t+o]*i;return i*=128,n>=i&&(n-=Math.pow(2,8*e)),n},t.prototype.readIntBE=function(t,e,r){t=0|t,e=0|e,r||B(t,e,this.length);for(var n=e,i=1,o=this[t+--n];n>0&&(i*=256);)o+=this[t+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*e)),o},t.prototype.readInt8=function(t,e){return e||B(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},t.prototype.readInt16LE=function(t,e){e||B(t,2,this.length);var r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},t.prototype.readInt16BE=function(t,e){e||B(t,2,this.length);var r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},t.prototype.readInt32LE=function(t,e){return e||B(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},t.prototype.readInt32BE=function(t,e){return e||B(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},t.prototype.readFloatLE=function(t,e){return e||B(t,4,this.length),X.read(this,t,!0,23,4)},t.prototype.readFloatBE=function(t,e){return e||B(t,4,this.length),X.read(this,t,!1,23,4)},t.prototype.readDoubleLE=function(t,e){return e||B(t,8,this.length),X.read(this,t,!0,52,8)},t.prototype.readDoubleBE=function(t,e){return e||B(t,8,this.length),X.read(this,t,!1,52,8)},t.prototype.writeUIntLE=function(t,e,r,n){t=+t,e=0|e,r=0|r,n||R(this,t,e,r,Math.pow(2,8*r),0);var i=1,o=0;for(this[e]=255&t;++o<r&&(i*=256);)this[e+o]=t/i&255;return e+r},t.prototype.writeUIntBE=function(t,e,r,n){t=+t,e=0|e,r=0|r,n||R(this,t,e,r,Math.pow(2,8*r),0);var i=r-1,o=1;for(this[e+i]=255&t;--i>=0&&(o*=256);)this[e+i]=t/o&255;return e+r},t.prototype.writeUInt8=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,1,255,0),t.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[r]=255&e,r+1},t.prototype.writeUInt16LE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,2,65535,0),t.TYPED_ARRAY_SUPPORT?(this[r]=255&e,this[r+1]=e>>>8):q(this,e,r,!0),r+2},t.prototype.writeUInt16BE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,2,65535,0),t.TYPED_ARRAY_SUPPORT?(this[r]=e>>>8,this[r+1]=255&e):q(this,e,r,!1),r+2},t.prototype.writeUInt32LE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,4,4294967295,0),t.TYPED_ARRAY_SUPPORT?(this[r+3]=e>>>24,this[r+2]=e>>>16,this[r+1]=e>>>8,this[r]=255&e):N(this,e,r,!0),r+4},t.prototype.writeUInt32BE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,4,4294967295,0),t.TYPED_ARRAY_SUPPORT?(this[r]=e>>>24,this[r+1]=e>>>16,this[r+2]=e>>>8,this[r+3]=255&e):N(this,e,r,!1),r+4},t.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e=0|e,!n){var i=Math.pow(2,8*r-1);R(this,t,e,r,i-1,-i)}var o=0,s=1,a=0>t?1:0;for(this[e]=255&t;++o<r&&(s*=256);)this[e+o]=(t/s>>0)-a&255;return e+r},t.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e=0|e,!n){var i=Math.pow(2,8*r-1);R(this,t,e,r,i-1,-i)}var o=r-1,s=1,a=0>t?1:0;for(this[e+o]=255&t;--o>=0&&(s*=256);)this[e+o]=(t/s>>0)-a&255;return e+r},t.prototype.writeInt8=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,1,127,-128),t.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),0>e&&(e=255+e+1),this[r]=255&e,r+1},t.prototype.writeInt16LE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,2,32767,-32768),t.TYPED_ARRAY_SUPPORT?(this[r]=255&e,this[r+1]=e>>>8):q(this,e,r,!0),r+2},t.prototype.writeInt16BE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,2,32767,-32768),t.TYPED_ARRAY_SUPPORT?(this[r]=e>>>8,this[r+1]=255&e):q(this,e,r,!1),r+2},t.prototype.writeInt32LE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,4,2147483647,-2147483648),t.TYPED_ARRAY_SUPPORT?(this[r]=255&e,this[r+1]=e>>>8,this[r+2]=e>>>16,this[r+3]=e>>>24):N(this,e,r,!0),r+4},t.prototype.writeInt32BE=function(e,r,n){return e=+e,r=0|r,n||R(this,e,r,4,2147483647,-2147483648),0>e&&(e=4294967295+e+1),t.TYPED_ARRAY_SUPPORT?(this[r]=e>>>24,this[r+1]=e>>>16,this[r+2]=e>>>8,this[r+3]=255&e):N(this,e,r,!1),r+4},t.prototype.writeFloatLE=function(t,e,r){return P(this,t,e,!0,r)},t.prototype.writeFloatBE=function(t,e,r){return P(this,t,e,!1,r)},t.prototype.writeDoubleLE=function(t,e,r){return M(this,t,e,!0,r)},t.prototype.writeDoubleBE=function(t,e,r){return M(this,t,e,!1,r)},t.prototype.copy=function(e,r,n,i){if(n||(n=0),i||0===i||(i=this.length),r>=e.length&&(r=e.length),r||(r=0),i>0&&n>i&&(i=n),i===n)return 0;if(0===e.length||0===this.length)return 0;if(0>r)throw new RangeError("targetStart out of bounds");if(0>n||n>=this.length)throw new RangeError("sourceStart out of bounds");if(0>i)throw new RangeError("sourceEnd out of bounds");i>this.length&&(i=this.length),e.length-r<i-n&&(i=e.length-r+n);var o,s=i-n;if(this===e&&r>n&&i>r)for(o=s-1;o>=0;o--)e[o+r]=this[o+n];else if(1e3>s||!t.TYPED_ARRAY_SUPPORT)for(o=0;s>o;o++)e[o+r]=this[o+n];else e._set(this.subarray(n,n+s),r);return s},t.prototype.fill=function(t,e,r){if(t||(t=0),e||(e=0),r||(r=this.length),e>r)throw new RangeError("end < start");if(r!==e&&0!==this.length){if(0>e||e>=this.length)throw new RangeError("start out of bounds");if(0>r||r>this.length)throw new RangeError("end out of bounds");var n;if("number"==typeof t)for(n=e;r>n;n++)this[n]=t;else{var i=H(t.toString()),o=i.length;for(n=e;r>n;n++)this[n]=i[n%o]}return this}},t.prototype.toArrayBuffer=function(){if("undefined"!=typeof Uint8Array){if(t.TYPED_ARRAY_SUPPORT)return new t(this).buffer;for(var e=new Uint8Array(this.length),r=0,n=e.length;n>r;r+=1)e[r]=this[r];return e.buffer}throw new TypeError("Buffer.toArrayBuffer not supported in this browser")};var $=t.prototype;t._augment=function(e){return e.constructor=t,e._isBuffer=!0,e._set=e.set,e.get=$.get,e.set=$.set,e.write=$.write,e.toString=$.toString,e.toLocaleString=$.toString,e.toJSON=$.toJSON,e.equals=$.equals,e.compare=$.compare,e.indexOf=$.indexOf,e.copy=$.copy,e.slice=$.slice,e.readUIntLE=$.readUIntLE,e.readUIntBE=$.readUIntBE,e.readUInt8=$.readUInt8,e.readUInt16LE=$.readUInt16LE,e.readUInt16BE=$.readUInt16BE,e.readUInt32LE=$.readUInt32LE,e.readUInt32BE=$.readUInt32BE,e.readIntLE=$.readIntLE,e.readIntBE=$.readIntBE,e.readInt8=$.readInt8,e.readInt16LE=$.readInt16LE,e.readInt16BE=$.readInt16BE,e.readInt32LE=$.readInt32LE,e.readInt32BE=$.readInt32BE,e.readFloatLE=$.readFloatLE,e.readFloatBE=$.readFloatBE,e.readDoubleLE=$.readDoubleLE,e.readDoubleBE=$.readDoubleBE,e.writeUInt8=$.writeUInt8,e.writeUIntLE=$.writeUIntLE,e.writeUIntBE=$.writeUIntBE,e.writeUInt16LE=$.writeUInt16LE,e.writeUInt16BE=$.writeUInt16BE,e.writeUInt32LE=$.writeUInt32LE,e.writeUInt32BE=$.writeUInt32BE,e.writeIntLE=$.writeIntLE,e.writeIntBE=$.writeIntBE,e.writeInt8=$.writeInt8,e.writeInt16LE=$.writeInt16LE,e.writeInt16BE=$.writeInt16BE,e.writeInt32LE=$.writeInt32LE,e.writeInt32BE=$.writeInt32BE,e.writeFloatLE=$.writeFloatLE,e.writeFloatBE=$.writeFloatBE,e.writeDoubleLE=$.writeDoubleLE,e.writeDoubleBE=$.writeDoubleBE,e.fill=$.fill,e.inspect=$.inspect,e.toArrayBuffer=$.toArrayBuffer,e};var tt=/[^+\/0-9A-Za-z-_]/g}).call(e,r(28).Buffer,function(){return this}())},function(t,e,r){var n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(t){"use strict";function e(t){var e=t.charCodeAt(0);return e===s||e===h?62:e===a||e===f?63:c>e?-1:c+10>e?e-c+26+26:l+26>e?e-l:u+26>e?e-u+26:void 0}function r(t){function r(t){u[h++]=t}var n,i,s,a,c,u;if(t.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var l=t.length;c="="===t.charAt(l-2)?2:"="===t.charAt(l-1)?1:0,u=new o(3*t.length/4-c),s=c>0?t.length-4:t.length;var h=0;for(n=0,i=0;s>n;n+=4,i+=3)a=e(t.charAt(n))<<18|e(t.charAt(n+1))<<12|e(t.charAt(n+2))<<6|e(t.charAt(n+3)),r((16711680&a)>>16),r((65280&a)>>8),r(255&a);return 2===c?(a=e(t.charAt(n))<<2|e(t.charAt(n+1))>>4,r(255&a)):1===c&&(a=e(t.charAt(n))<<10|e(t.charAt(n+1))<<4|e(t.charAt(n+2))>>2,r(a>>8&255),r(255&a)),u}function i(t){function e(t){return n.charAt(t)}function r(t){return e(t>>18&63)+e(t>>12&63)+e(t>>6&63)+e(63&t)}var i,o,s,a=t.length%3,c="";for(i=0,s=t.length-a;s>i;i+=3)o=(t[i]<<16)+(t[i+1]<<8)+t[i+2],c+=r(o);switch(a){case 1:o=t[t.length-1],c+=e(o>>2),c+=e(o<<4&63),c+="==";break;case 2:o=(t[t.length-2]<<8)+t[t.length-1],c+=e(o>>10),c+=e(o>>4&63),c+=e(o<<2&63),c+="="}return c}var o="undefined"!=typeof Uint8Array?Uint8Array:Array,s="+".charCodeAt(0),a="/".charCodeAt(0),c="0".charCodeAt(0),u="a".charCodeAt(0),l="A".charCodeAt(0),h="-".charCodeAt(0),f="_".charCodeAt(0);t.toByteArray=r,t.fromByteArray=i}(e)},function(t,e){e.read=function(t,e,r,n,i){var o,s,a=8*i-n-1,c=(1<<a)-1,u=c>>1,l=-7,h=r?i-1:0,f=r?-1:1,p=t[e+h];for(h+=f,o=p&(1<<-l)-1,p>>=-l,l+=a;l>0;o=256*o+t[e+h],h+=f,l-=8);for(s=o&(1<<-l)-1,o>>=-l,l+=n;l>0;s=256*s+t[e+h],h+=f,l-=8);if(0===o)o=1-u;else{if(o===c)return s?NaN:(p?-1:1)*(1/0);s+=Math.pow(2,n),o-=u}return(p?-1:1)*s*Math.pow(2,o-n)},e.write=function(t,e,r,n,i,o){var s,a,c,u=8*o-i-1,l=(1<<u)-1,h=l>>1,f=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,g=0>e||0===e&&0>1/e?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(a=isNaN(e)?1:0,s=l):(s=Math.floor(Math.log(e)/Math.LN2),e*(c=Math.pow(2,-s))<1&&(s--,c*=2),e+=s+h>=1?f/c:f*Math.pow(2,1-h),e*c>=2&&(s++,c/=2),s+h>=l?(a=0,s=l):s+h>=1?(a=(e*c-1)*Math.pow(2,i),s+=h):(a=e*Math.pow(2,h-1)*Math.pow(2,i),s=0));i>=8;t[r+p]=255&a,p+=d,a/=256,i-=8);for(s=s<<i|a,u+=i;u>0;t[r+p]=255&s,p+=d,s/=256,u-=8);t[r+p-d]|=128*g}},function(t,e){var r={}.toString;t.exports=Array.isArray||function(t){return"[object Array]"==r.call(t)}},function(t,e,r){(function(t){function r(t){return Array.isArray?Array.isArray(t):"[object Array]"===b(t)}function n(t){return"boolean"==typeof t}function i(t){return null===t}function o(t){return null==t}function s(t){return"number"==typeof t}function a(t){return"string"==typeof t}function c(t){return"symbol"==typeof t}function u(t){return void 0===t}function l(t){return"[object RegExp]"===b(t)}function h(t){return"object"==typeof t&&null!==t}function f(t){return"[object Date]"===b(t)}function p(t){return"[object Error]"===b(t)||t instanceof Error}function d(t){return"function"==typeof t}function g(t){return null===t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||"symbol"==typeof t||"undefined"==typeof t}function b(t){return Object.prototype.toString.call(t)}e.isArray=r,e.isBoolean=n,e.isNull=i,e.isNullOrUndefined=o,e.isNumber=s,e.isString=a,e.isSymbol=c,e.isUndefined=u,e.isRegExp=l,e.isObject=h,e.isDate=f,e.isError=p,e.isFunction=d,e.isPrimitive=g,e.isBuffer=t.isBuffer}).call(e,r(28).Buffer)},function(t,e){"function"==typeof Object.create?t.exports=function(t,e){t.super_=e,t.prototype=Object.create(e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(t,e){t.super_=e;var r=function(){};r.prototype=e.prototype,t.prototype=new r,t.prototype.constructor=t}},function(t,e){},function(t,e,r){(function(e){function n(t){return this instanceof n?(c.call(this,t),u.call(this,t),t&&t.readable===!1&&(this.readable=!1),t&&t.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,t&&t.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",i)):new n(t)}function i(){this.allowHalfOpen||this._writableState.ended||e.nextTick(this.end.bind(this))}function o(t,e){for(var r=0,n=t.length;n>r;r++)e(t[r],r)}t.exports=n;var s=Object.keys||function(t){var e=[];for(var r in t)e.push(r);return e},a=r(32);a.inherits=r(33);var c=r(26),u=r(36);a.inherits(n,c),o(s(u.prototype),function(t){n.prototype[t]||(n.prototype[t]=u.prototype[t])})}).call(e,r(3))},function(t,e,r){(function(e){function n(t,e,r){this.chunk=t,this.encoding=e,this.callback=r}function i(t,e){var n=r(35);t=t||{};var i=t.highWaterMark,o=t.objectMode?16:16384;this.highWaterMark=i||0===i?i:o,this.objectMode=!!t.objectMode,e instanceof n&&(this.objectMode=this.objectMode||!!t.writableObjectMode),this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var s=t.decodeStrings===!1;this.decodeStrings=!s,this.defaultEncoding=t.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(t){p(e,t)},this.writecb=null,this.writelen=0,this.buffer=[],this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1}function o(t){var e=r(35);return this instanceof o||this instanceof e?(this._writableState=new i(t,this),this.writable=!0,void S.call(this)):new o(t)}function s(t,r,n){var i=new Error("write after end");t.emit("error",i),e.nextTick(function(){n(i)})}function a(t,r,n,i){var o=!0;if(!(x.isBuffer(n)||x.isString(n)||x.isNullOrUndefined(n)||r.objectMode)){var s=new TypeError("Invalid non-string/buffer chunk");t.emit("error",s),e.nextTick(function(){i(s)}),o=!1}return o}function c(t,e,r){return!t.objectMode&&t.decodeStrings!==!1&&x.isString(e)&&(e=new w(e,r)),e}function u(t,e,r,i,o){r=c(e,r,i),x.isBuffer(r)&&(i="buffer");var s=e.objectMode?1:r.length;e.length+=s;var a=e.length<e.highWaterMark;return a||(e.needDrain=!0),e.writing||e.corked?e.buffer.push(new n(r,i,o)):l(t,e,!1,s,r,i,o),a}function l(t,e,r,n,i,o,s){e.writelen=n,e.writecb=s,e.writing=!0,e.sync=!0,r?t._writev(i,e.onwrite):t._write(i,o,e.onwrite),e.sync=!1}function h(t,r,n,i,o){n?e.nextTick(function(){r.pendingcb--,o(i)}):(r.pendingcb--,o(i)),t._writableState.errorEmitted=!0,t.emit("error",i)}function f(t){t.writing=!1,t.writecb=null,t.length-=t.writelen,t.writelen=0}function p(t,r){var n=t._writableState,i=n.sync,o=n.writecb;if(f(n),r)h(t,n,i,r,o);else{var s=_(t,n);s||n.corked||n.bufferProcessing||!n.buffer.length||b(t,n),i?e.nextTick(function(){d(t,n,s,o)}):d(t,n,s,o)}}function d(t,e,r,n){r||g(t,e),e.pendingcb--,n(),y(t,e)}function g(t,e){0===e.length&&e.needDrain&&(e.needDrain=!1,t.emit("drain"))}function b(t,e){if(e.bufferProcessing=!0,t._writev&&e.buffer.length>1){for(var r=[],n=0;n<e.buffer.length;n++)r.push(e.buffer[n].callback);e.pendingcb++,l(t,e,!0,e.length,e.buffer,"",function(t){for(var n=0;n<r.length;n++)e.pendingcb--,r[n](t)}),e.buffer=[]}else{for(var n=0;n<e.buffer.length;n++){var i=e.buffer[n],o=i.chunk,s=i.encoding,a=i.callback,c=e.objectMode?1:o.length;if(l(t,e,!1,c,o,s,a),e.writing){n++;break}}n<e.buffer.length?e.buffer=e.buffer.slice(n):e.buffer.length=0}e.bufferProcessing=!1}function _(t,e){return e.ending&&0===e.length&&!e.finished&&!e.writing}function m(t,e){e.prefinished||(e.prefinished=!0,t.emit("prefinish"))}function y(t,e){var r=_(t,e);return r&&(0===e.pendingcb?(m(t,e),e.finished=!0,t.emit("finish")):m(t,e)),r}function v(t,r,n){r.ending=!0,y(t,r),n&&(r.finished?e.nextTick(n):t.once("finish",n)),r.ended=!0}t.exports=o;var w=r(28).Buffer;o.WritableState=i;var x=r(32);x.inherits=r(33);var S=r(23);x.inherits(o,S),o.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},o.prototype.write=function(t,e,r){var n=this._writableState,i=!1;return x.isFunction(e)&&(r=e,e=null),x.isBuffer(t)?e="buffer":e||(e=n.defaultEncoding),x.isFunction(r)||(r=function(){}),n.ended?s(this,n,r):a(this,n,t,r)&&(n.pendingcb++,i=u(this,n,t,e,r)),i},o.prototype.cork=function(){var t=this._writableState;t.corked++},o.prototype.uncork=function(){var t=this._writableState;t.corked&&(t.corked--,t.writing||t.corked||t.finished||t.bufferProcessing||!t.buffer.length||b(this,t))},o.prototype._write=function(t,e,r){r(new Error("not implemented"))},o.prototype._writev=null,o.prototype.end=function(t,e,r){var n=this._writableState;x.isFunction(t)?(r=t,t=null,e=null):x.isFunction(e)&&(r=e,e=null),x.isNullOrUndefined(t)||this.write(t,e),n.corked&&(n.corked=1,this.uncork()),n.ending||n.finished||v(this,n,r)}}).call(e,r(3))},function(t,e,r){function n(t){if(t&&!c(t))throw new Error("Unknown encoding: "+t)}function i(t){return t.toString(this.encoding)}function o(t){this.charReceived=t.length%2,this.charLength=this.charReceived?2:0}function s(t){this.charReceived=t.length%3,this.charLength=this.charReceived?3:0}var a=r(28).Buffer,c=a.isEncoding||function(t){switch(t&&t.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},u=e.StringDecoder=function(t){switch(this.encoding=(t||"utf8").toLowerCase().replace(/[-_]/,""),n(t),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=i)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};u.prototype.write=function(t){for(var e="";this.charLength;){var r=t.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:t.length;if(t.copy(this.charBuffer,this.charReceived,0,r),this.charReceived+=r,this.charReceived<this.charLength)return"";t=t.slice(r,t.length),e=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var n=e.charCodeAt(e.length-1);if(!(n>=55296&&56319>=n)){if(this.charReceived=this.charLength=0,0===t.length)return e;break}this.charLength+=this.surrogateSize,e=""}this.detectIncompleteChar(t);var i=t.length;this.charLength&&(t.copy(this.charBuffer,0,t.length-this.charReceived,i),i-=this.charReceived),e+=t.toString(this.encoding,0,i);var i=e.length-1,n=e.charCodeAt(i);if(n>=55296&&56319>=n){var o=this.surrogateSize;return this.charLength+=o,this.charReceived+=o,this.charBuffer.copy(this.charBuffer,o,0,o),t.copy(this.charBuffer,0,0,o),e.substring(0,i)}return e},u.prototype.detectIncompleteChar=function(t){for(var e=t.length>=3?3:t.length;e>0;e--){var r=t[t.length-e];if(1==e&&r>>5==6){this.charLength=2;break}if(2>=e&&r>>4==14){this.charLength=3;break}if(3>=e&&r>>3==30){this.charLength=4;break}}this.charReceived=e},u.prototype.end=function(t){var e="";if(t&&t.length&&(e=this.write(t)),this.charReceived){var r=this.charReceived,n=this.charBuffer,i=this.encoding;e+=n.slice(0,r).toString(i)}return e}},function(t,e,r){function n(t,e){this.afterTransform=function(t,r){return i(e,t,r)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function i(t,e,r){var n=t._transformState;n.transforming=!1;var i=n.writecb;if(!i)return t.emit("error",new Error("no writecb in Transform class"));n.writechunk=null,n.writecb=null,c.isNullOrUndefined(r)||t.push(r),i&&i(e);var o=t._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&t._read(o.highWaterMark)}function o(t){if(!(this instanceof o))return new o(t);a.call(this,t),this._transformState=new n(t,this);var e=this;this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("prefinish",function(){c.isFunction(this._flush)?this._flush(function(t){s(e,t)}):s(e)})}function s(t,e){if(e)return t.emit("error",e);var r=t._writableState,n=t._transformState;if(r.length)throw new Error("calling transform done when ws.length != 0");if(n.transforming)throw new Error("calling transform done when still transforming");return t.push(null)}t.exports=o;var a=r(35),c=r(32);c.inherits=r(33),c.inherits(o,a),o.prototype.push=function(t,e){return this._transformState.needTransform=!1,a.prototype.push.call(this,t,e)},o.prototype._transform=function(t,e,r){throw new Error("not implemented")},o.prototype._write=function(t,e,r){var n=this._transformState;if(n.writecb=r,n.writechunk=t,n.writeencoding=e,!n.transforming){var i=this._readableState;(n.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},o.prototype._read=function(t){var e=this._transformState;c.isNull(e.writechunk)||!e.writecb||e.transforming?e.needTransform=!0:(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform))}},function(t,e,r){function n(t){return this instanceof n?void i.call(this,t):new n(t)}t.exports=n;var i=r(38),o=r(32);o.inherits=r(33),o.inherits(n,i),n.prototype._transform=function(t,e,r){r(null,t)}},function(t,e,r){t.exports=r(36)},function(t,e,r){t.exports=r(35)},function(t,e,r){t.exports=r(38)},function(t,e,r){t.exports=r(39)},function(t,e){},function(t,e,r){function n(t){this._cbs=t||{}}t.exports=n;var i=r(8).EVENTS;Object.keys(i).forEach(function(t){if(0===i[t])t="on"+t,n.prototype[t]=function(){this._cbs[t]&&this._cbs[t]()};else if(1===i[t])t="on"+t,n.prototype[t]=function(e){this._cbs[t]&&this._cbs[t](e)};else{if(2!==i[t])throw Error("wrong number of arguments");t="on"+t,n.prototype[t]=function(e,r){this._cbs[t]&&this._cbs[t](e,r)}}})},function(t,e,r){var n=t.exports;[r(47),r(53),r(54),r(55),r(56),r(57)].forEach(function(t){Object.keys(t).forEach(function(e){n[e]=t[e].bind(n);
+})})},function(t,e,r){function n(t,e){return t.children?t.children.map(function(t){return s(t,e)}).join(""):""}function i(t){return Array.isArray(t)?t.map(i).join(""):a(t)||t.type===o.CDATA?i(t.children):t.type===o.Text?t.data:""}var o=r(17),s=r(48),a=o.isTag;t.exports={getInnerHTML:n,getOuterHTML:s,getText:i}},function(t,e,r){function n(t,e){if(t){var r,n="";for(var i in t)r=t[i],n&&(n+=" "),n+=!r&&h[i]?i:i+'="'+(e.decodeEntities?l.encodeXML(r):r)+'"';return n}}function i(t,e){"svg"===t.name&&(e={decodeEntities:e.decodeEntities,xmlMode:!0});var r="<"+t.name,i=n(t.attribs,e);return i&&(r+=" "+i),!e.xmlMode||t.children&&0!==t.children.length?(r+=">",t.children&&(r+=d(t.children,e)),p[t.name]&&!e.xmlMode||(r+="</"+t.name+">")):r+="/>",r}function o(t){return"<"+t.data+">"}function s(t,e){var r=t.data||"";return!e.decodeEntities||t.parent&&t.parent.name in f||(r=l.encodeXML(r)),r}function a(t){return"<![CDATA["+t.children[0].data+"]]>"}function c(t){return"<!--"+t.data+"-->"}var u=r(49),l=r(50),h={__proto__:null,allowfullscreen:!0,async:!0,autofocus:!0,autoplay:!0,checked:!0,controls:!0,"default":!0,defer:!0,disabled:!0,hidden:!0,ismap:!0,loop:!0,multiple:!0,muted:!0,open:!0,readonly:!0,required:!0,reversed:!0,scoped:!0,seamless:!0,selected:!0,typemustmatch:!0},f={__proto__:null,style:!0,script:!0,xmp:!0,iframe:!0,noembed:!0,noframes:!0,plaintext:!0,noscript:!0},p={__proto__:null,area:!0,base:!0,basefont:!0,br:!0,col:!0,command:!0,embed:!0,frame:!0,hr:!0,img:!0,input:!0,isindex:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0},d=t.exports=function(t,e){Array.isArray(t)||t.cheerio||(t=[t]),e=e||{};for(var r="",n=0;n<t.length;n++){var l=t[n];r+="root"===l.type?d(l.children,e):u.isTag(l)?i(l,e):l.type===u.Directive?o(l):l.type===u.Comment?c(l):l.type===u.CDATA?a(l):s(l,e)}return r}},function(t,e){t.exports={Text:"text",Directive:"directive",Comment:"comment",Script:"script",Style:"style",Tag:"tag",CDATA:"cdata",isTag:function(t){return"tag"===t.type||"script"===t.type||"style"===t.type}}},function(t,e,r){var n=r(51),i=r(52);e.decode=function(t,e){return(!e||0>=e?i.XML:i.HTML)(t)},e.decodeStrict=function(t,e){return(!e||0>=e?i.XML:i.HTMLStrict)(t)},e.encode=function(t,e){return(!e||0>=e?n.XML:n.HTML)(t)},e.encodeXML=n.XML,e.encodeHTML4=e.encodeHTML5=e.encodeHTML=n.HTML,e.decodeXML=e.decodeXMLStrict=i.XML,e.decodeHTML4=e.decodeHTML5=e.decodeHTML=i.HTML,e.decodeHTML4Strict=e.decodeHTML5Strict=e.decodeHTMLStrict=i.HTMLStrict,e.escape=n.escape},function(t,e,r){function n(t){return Object.keys(t).sort().reduce(function(e,r){return e[t[r]]="&"+r+";",e},{})}function i(t){var e=[],r=[];return Object.keys(t).forEach(function(t){1===t.length?e.push("\\"+t):r.push(t)}),r.unshift("["+e.join("")+"]"),new RegExp(r.join("|"),"g")}function o(t){return"&#x"+t.charCodeAt(0).toString(16).toUpperCase()+";"}function s(t){var e=t.charCodeAt(0),r=t.charCodeAt(1),n=1024*(e-55296)+r-56320+65536;return"&#x"+n.toString(16).toUpperCase()+";"}function a(t,e){function r(e){return t[e]}return function(t){return t.replace(e,r).replace(d,s).replace(p,o)}}function c(t){return t.replace(g,o).replace(d,s).replace(p,o)}var u=n(r(15)),l=i(u);e.XML=a(u,l);var h=n(r(13)),f=i(h);e.HTML=a(h,f);var p=/[^\0-\x7F]/g,d=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,g=i(u);e.escape=c},function(t,e,r){function n(t){var e=Object.keys(t).join("|"),r=o(t);e+="|#[xX][\\da-fA-F]+|#\\d+";var n=new RegExp("&(?:"+e+");","g");return function(t){return String(t).replace(n,r)}}function i(t,e){return e>t?1:-1}function o(t){return function(e){return"#"===e.charAt(1)?u("X"===e.charAt(2)||"x"===e.charAt(2)?parseInt(e.substr(3),16):parseInt(e.substr(2),10)):t[e.slice(1,-1)]}}var s=r(13),a=r(14),c=r(15),u=r(11),l=n(c),h=n(s),f=function(){function t(t){return";"!==t.substr(-1)&&(t+=";"),l(t)}for(var e=Object.keys(a).sort(i),r=Object.keys(s).sort(i),n=0,c=0;n<r.length;n++)e[c]===r[n]?(r[n]+=";?",c++):r[n]+=";";var u=new RegExp("&(?:"+r.join("|")+"|#[xX][\\da-fA-F]+;?|#\\d+;?)","g"),l=o(s);return function(e){return String(e).replace(u,t)}}();t.exports={XML:l,HTML:f,HTMLStrict:h}},function(t,e){var r=e.getChildren=function(t){return t.children},n=e.getParent=function(t){return t.parent};e.getSiblings=function(t){var e=n(t);return e?r(e):[t]},e.getAttributeValue=function(t,e){return t.attribs&&t.attribs[e]},e.hasAttrib=function(t,e){return!!t.attribs&&hasOwnProperty.call(t.attribs,e)},e.getName=function(t){return t.name}},function(t,e){e.removeElement=function(t){if(t.prev&&(t.prev.next=t.next),t.next&&(t.next.prev=t.prev),t.parent){var e=t.parent.children;e.splice(e.lastIndexOf(t),1)}},e.replaceElement=function(t,e){var r=e.prev=t.prev;r&&(r.next=e);var n=e.next=t.next;n&&(n.prev=e);var i=e.parent=t.parent;if(i){var o=i.children;o[o.lastIndexOf(t)]=e}},e.appendChild=function(t,e){if(e.parent=t,1!==t.children.push(e)){var r=t.children[t.children.length-2];r.next=e,e.prev=r,e.next=null}},e.append=function(t,e){var r=t.parent,n=t.next;if(e.next=n,e.prev=t,t.next=e,e.parent=r,n){if(n.prev=e,r){var i=r.children;i.splice(i.lastIndexOf(n),0,e)}}else r&&r.children.push(e)},e.prepend=function(t,e){var r=t.parent;if(r){var n=r.children;n.splice(n.lastIndexOf(t),0,e)}t.prev&&(t.prev.next=e),e.parent=r,e.prev=t.prev,e.next=t,t.prev=e}},function(t,e,r){function n(t,e,r,n){return Array.isArray(e)||(e=[e]),"number"==typeof n&&isFinite(n)||(n=1/0),i(t,e,r!==!1,n)}function i(t,e,r,n){for(var o,s=[],a=0,c=e.length;c>a&&!(t(e[a])&&(s.push(e[a]),--n<=0))&&(o=e[a].children,!(r&&o&&o.length>0&&(o=i(t,o,r,n),s=s.concat(o),n-=o.length,0>=n)));a++);return s}function o(t,e){for(var r=0,n=e.length;n>r;r++)if(t(e[r]))return e[r];return null}function s(t,e){for(var r=null,n=0,i=e.length;i>n&&!r;n++)u(e[n])&&(t(e[n])?r=e[n]:e[n].children.length>0&&(r=s(t,e[n].children)));return r}function a(t,e){for(var r=0,n=e.length;n>r;r++)if(u(e[r])&&(t(e[r])||e[r].children.length>0&&a(t,e[r].children)))return!0;return!1}function c(t,e){for(var r=[],n=0,i=e.length;i>n;n++)u(e[n])&&(t(e[n])&&r.push(e[n]),e[n].children.length>0&&(r=r.concat(c(t,e[n].children))));return r}var u=r(17).isTag;t.exports={filter:n,find:i,findOneChild:o,findOne:s,existsOne:a,findAll:c}},function(t,e,r){function n(t,e){return"function"==typeof e?function(r){return r.attribs&&e(r.attribs[t])}:function(r){return r.attribs&&r.attribs[t]===e}}function i(t,e){return function(r){return t(r)||e(r)}}var o=r(17),s=e.isTag=o.isTag;e.testElement=function(t,e){for(var r in t)if(t.hasOwnProperty(r)){if("tag_name"===r){if(!s(e)||!t.tag_name(e.name))return!1}else if("tag_type"===r){if(!t.tag_type(e.type))return!1}else if("tag_contains"===r){if(s(e)||!t.tag_contains(e.data))return!1}else if(!e.attribs||!t[r](e.attribs[r]))return!1}else;return!0};var a={tag_name:function(t){return"function"==typeof t?function(e){return s(e)&&t(e.name)}:"*"===t?s:function(e){return s(e)&&e.name===t}},tag_type:function(t){return"function"==typeof t?function(e){return t(e.type)}:function(e){return e.type===t}},tag_contains:function(t){return"function"==typeof t?function(e){return!s(e)&&t(e.data)}:function(e){return!s(e)&&e.data===t}}};e.getElements=function(t,e,r,o){var s=Object.keys(t).map(function(e){var r=t[e];return e in a?a[e](r):n(e,r)});return 0===s.length?[]:this.filter(s.reduce(i),e,r,o)},e.getElementById=function(t,e,r){return Array.isArray(e)||(e=[e]),this.findOne(n("id",t),e,r!==!1)},e.getElementsByTagName=function(t,e,r,n){return this.filter(a.tag_name(t),e,r,n)},e.getElementsByTagType=function(t,e,r,n){return this.filter(a.tag_type(t),e,r,n)}},function(t,e){e.removeSubsets=function(t){for(var e,r,n,i=t.length;--i>-1;){for(e=r=t[i],t[i]=null,n=!0;r;){if(t.indexOf(r)>-1){n=!1,t.splice(i,1);break}r=r.parent}n&&(t[i]=e)}return t};var r={DISCONNECTED:1,PRECEDING:2,FOLLOWING:4,CONTAINS:8,CONTAINED_BY:16},n=e.compareDocumentPosition=function(t,e){var n,i,o,s,a,c,u=[],l=[];if(t===e)return 0;for(n=t;n;)u.unshift(n),n=n.parent;for(n=e;n;)l.unshift(n),n=n.parent;for(c=0;u[c]===l[c];)c++;return 0===c?r.DISCONNECTED:(i=u[c-1],o=i.children,s=u[c],a=l[c],o.indexOf(s)>o.indexOf(a)?i===e?r.FOLLOWING|r.CONTAINED_BY:r.FOLLOWING:i===t?r.PRECEDING|r.CONTAINS:r.PRECEDING)};e.uniqueSort=function(t){var e,i,o=t.length;for(t=t.slice();--o>-1;)e=t[o],i=t.indexOf(e),i>-1&&o>i&&t.splice(o,1);return t.sort(function(t,e){var i=n(t,e);return i&r.PRECEDING?-1:i&r.FOLLOWING?1:0}),t}},function(t,e,r){function n(t){this._cbs=t||{},this.events=[]}t.exports=n;var i=r(8).EVENTS;Object.keys(i).forEach(function(t){if(0===i[t])t="on"+t,n.prototype[t]=function(){this.events.push([t]),this._cbs[t]&&this._cbs[t]()};else if(1===i[t])t="on"+t,n.prototype[t]=function(e){this.events.push([t,e]),this._cbs[t]&&this._cbs[t](e)};else{if(2!==i[t])throw Error("wrong number of arguments");t="on"+t,n.prototype[t]=function(e,r){this.events.push([t,e,r]),this._cbs[t]&&this._cbs[t](e,r)}}}),n.prototype.onreset=function(){this.events=[],this._cbs.onreset&&this._cbs.onreset()},n.prototype.restart=function(){this._cbs.onreset&&this._cbs.onreset();for(var t=0,e=this.events.length;e>t;t++)if(this._cbs[this.events[t][0]]){var r=this.events[t].length;1===r?this._cbs[this.events[t][0]]():2===r?this._cbs[this.events[t][0]](this.events[t][1]):this._cbs[this.events[t][0]](this.events[t][1],this.events[t][2])}}},function(t,e,r){"use strict";var n=r(60),i=r(61),o=r(67);t.exports=function(t){var e,s=n(arguments[1]);return s.normalizer||(e=s.length=i(s.length,t.length,s.async),0!==e&&(s.primitive?e===!1?s.normalizer=r(104):e>1&&(s.normalizer=r(105)(e)):e===!1?s.normalizer=r(106)():1===e?s.normalizer=r(108)():s.normalizer=r(109)(e))),s.async&&r(110),s.dispose&&r(113),s.maxAge&&r(114),s.max&&r(117),s.refCounter&&r(119),o(t,s)}},function(t,e){"use strict";var r=Array.prototype.forEach,n=Object.create,i=function(t,e){var r;for(r in t)e[r]=t[r]};t.exports=function(t){var e=n(null);return r.call(arguments,function(t){null!=t&&i(Object(t),e)}),e}},function(t,e,r){"use strict";var n=r(62);t.exports=function(t,e,r){var i;return isNaN(t)?(i=e,i>=0?r&&i?i-1:i:1):t===!1?!1:n(t)}},function(t,e,r){"use strict";var n=r(63),i=Math.max;t.exports=function(t){return i(0,n(t))}},function(t,e,r){"use strict";var n=r(64),i=Math.abs,o=Math.floor;t.exports=function(t){return isNaN(t)?0:(t=Number(t),0!==t&&isFinite(t)?n(t)*o(i(t)):t)}},function(t,e,r){"use strict";t.exports=r(65)()?Math.sign:r(66)},function(t,e){"use strict";t.exports=function(){var t=Math.sign;return"function"!=typeof t?!1:1===t(10)&&-1===t(-20)}},function(t,e){"use strict";t.exports=function(t){return t=Number(t),isNaN(t)||0===t?t:t>0?1:-1}},function(t,e,r){"use strict";var n=r(68),i=r(69),o=r(72),s=r(73),a=r(61),c=Object.prototype.hasOwnProperty;t.exports=function u(t){var e,r,l;return n(t),e=Object(arguments[1]),c.call(t,"__memoized__")&&!e.force?t:(r=a(e.length,t.length,e.async&&o.async),l=s(t,r,e),i(o,function(t,r){e[r]&&t(e[r],l,e)}),u.__profiler__&&u.__profiler__(l),l.updateEnv(),l.memoized)}},function(t,e){"use strict";t.exports=function(t){if("function"!=typeof t)throw new TypeError(t+" is not a function");return t}},function(t,e,r){"use strict";t.exports=r(70)("forEach")},function(t,e,r){"use strict";var n=r(68),i=r(71),o=Function.prototype.bind,s=Function.prototype.call,a=Object.keys,c=Object.prototype.propertyIsEnumerable;t.exports=function(t,e){return function(r,u){var l,h=arguments[2],f=arguments[3];return r=Object(i(r)),n(u),l=a(r),f&&l.sort("function"==typeof f?o.call(f,r):void 0),"function"!=typeof t&&(t=l[t]),s.call(t,l,function(t,n){return c.call(r,t)?s.call(u,h,r[t],t,r,n):e})}}},function(t,e){"use strict";t.exports=function(t){if(null==t)throw new TypeError("Cannot use null or undefined");return t}},function(t,e){"use strict"},function(t,e,r){"use strict";var n=r(74),i=r(81),o=r(83),s=r(88).methods,a=r(89),c=r(103),u=Function.prototype.apply,l=Function.prototype.call,h=Object.create,f=Object.prototype.hasOwnProperty,p=Object.defineProperties,d=s.on,g=s.emit;t.exports=function(t,e,r){var s,b,_,m,y,v,w,x,S,E,A,T,k,L=h(null);return b=e!==!1?e:isNaN(t.length)?1:t.length,r.normalizer&&(x=c(r.normalizer),_=x.get,m=x.set,y=x["delete"],v=x.clear),null!=r.resolvers&&(k=a(r.resolvers)),T=_?i(function(e){var r,i,o=arguments;if(k&&(o=k(o)),r=_(o),null!==r&&f.call(L,r))return S&&s.emit("get",r,o,this),L[r];if(i=1===o.length?l.call(t,this,o[0]):u.call(t,this,o),null===r){if(r=_(o),null!==r)throw n("Circular invocation","CIRCULAR_INVOCATION");r=m(o)}else if(f.call(L,r))throw n("Circular invocation","CIRCULAR_INVOCATION");return L[r]=i,E&&s.emit("set",r),i},b):0===e?function(){var e;if(f.call(L,"data"))return S&&s.emit("get","data",arguments,this),L.data;if(e=arguments.length?u.call(t,this,arguments):l.call(t,this),f.call(L,"data"))throw n("Circular invocation","CIRCULAR_INVOCATION");return L.data=e,E&&s.emit("set","data"),e}:function(e){var r,i,o=arguments;if(k&&(o=k(arguments)),i=String(o[0]),f.call(L,i))return S&&s.emit("get",i,o,this),L[i];if(r=1===o.length?l.call(t,this,o[0]):u.call(t,this,o),f.call(L,i))throw n("Circular invocation","CIRCULAR_INVOCATION");return L[i]=r,E&&s.emit("set",i),r},s={original:t,memoized:T,get:function(t){return k&&(t=k(t)),_?_(t):String(t[0])},has:function(t){return f.call(L,t)},"delete":function(t){var e;f.call(L,t)&&(y&&y(t),e=L[t],delete L[t],A&&s.emit("delete",t,e))},clear:function(){var t=L;v&&v(),L=h(null),s.emit("clear",t)},on:function(t,e){return"get"===t?S=!0:"set"===t?E=!0:"delete"===t&&(A=!0),d.call(this,t,e)},emit:g,updateEnv:function(){t=s.original}},w=_?i(function(t){var e,r=arguments;k&&(r=k(r)),e=_(r),null!==e&&s["delete"](e)},b):0===e?function(){return s["delete"]("data")}:function(t){return k&&(t=k(arguments)[0]),s["delete"](t)},p(T,{__memoized__:o(!0),"delete":o(w),clear:o(s.clear)}),s}},function(t,e,r){"use strict";var n=r(75),i=Error.captureStackTrace;e=t.exports=function(t){var r=new Error,o=arguments[1],s=arguments[2];return null==s&&o&&"object"==typeof o&&(s=o,o=null),null!=s&&n(r,s),r.message=String(t),null!=o&&(r.code=String(o)),i&&i(r,e),r}},function(t,e,r){"use strict";t.exports=r(76)()?Object.assign:r(77)},function(t,e){"use strict";t.exports=function(){var t,e=Object.assign;return"function"!=typeof e?!1:(t={foo:"raz"},e(t,{bar:"dwa"},{trzy:"trzy"}),t.foo+t.bar+t.trzy==="razdwatrzy")}},function(t,e,r){"use strict";var n=r(78),i=r(71),o=Math.max;t.exports=function(t,e){var r,s,a,c=o(arguments.length,2);for(t=Object(i(t)),a=function(n){try{t[n]=e[n]}catch(i){r||(r=i)}},s=1;c>s;++s)e=arguments[s],n(e).forEach(a);if(void 0!==r)throw r;return t}},function(t,e,r){"use strict";t.exports=r(79)()?Object.keys:r(80)},function(t,e){"use strict";t.exports=function(){try{return Object.keys("primitive"),!0}catch(t){return!1}}},function(t,e){"use strict";var r=Object.keys;t.exports=function(t){return r(null==t?t:Object(t))}},function(t,e,r){"use strict";var n,i,o,s,a=r(62),c=function(t,e){};try{Object.defineProperty(c,"length",{configurable:!0,writable:!1,enumerable:!1,value:1})}catch(u){}1===c.length?(n={configurable:!0,writable:!1,enumerable:!1},i=Object.defineProperty,t.exports=function(t,e){return e=a(e),t.length===e?t:(n.value=e,i(t,"length",n))}):(s=r(82),o=function(){var t=[];return function(e){var r,n=0;if(t[e])return t[e];for(r=[];e--;)r.push("a"+(++n).toString(36));return new Function("fn","return function ("+r.join(", ")+") { return fn.apply(this, arguments); };")}}(),t.exports=function(t,e){var r;if(e=a(e),t.length===e)return t;r=o(e)(t);try{s(r,t)}catch(n){}return r})},function(t,e,r){"use strict";var n=r(71),i=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames;t.exports=function(t,e){var r;if(t=Object(n(t)),s(Object(n(e))).forEach(function(n){try{i(t,n,o(e,n))}catch(s){r=s}}),void 0!==r)throw r;return t}},function(t,e,r){"use strict";var n,i=r(75),o=r(60),s=r(84),a=r(85);n=t.exports=function(t,e){var r,n,s,c,u;return arguments.length<2||"string"!=typeof t?(c=e,e=t,t=null):c=arguments[2],null==t?(r=s=!0,n=!1):(r=a.call(t,"c"),n=a.call(t,"e"),s=a.call(t,"w")),u={value:e,configurable:r,enumerable:n,writable:s},c?i(o(c),u):u},n.gs=function(t,e,r){var n,c,u,l;return"string"!=typeof t?(u=r,r=e,e=t,t=null):u=arguments[3],null==e?e=void 0:s(e)?null==r?r=void 0:s(r)||(u=r,r=void 0):(u=e,e=r=void 0),null==t?(n=!0,c=!1):(n=a.call(t,"c"),c=a.call(t,"e")),l={get:e,set:r,configurable:n,enumerable:c},u?i(o(u),l):l}},function(t,e){"use strict";t.exports=function(t){return"function"==typeof t}},function(t,e,r){"use strict";t.exports=r(86)()?String.prototype.contains:r(87)},function(t,e){"use strict";var r="razdwatrzy";t.exports=function(){return"function"!=typeof r.contains?!1:r.contains("dwa")===!0&&r.contains("foo")===!1}},function(t,e){"use strict";var r=String.prototype.indexOf;t.exports=function(t){return r.call(this,t,arguments[1])>-1}},function(t,e,r){"use strict";var n,i,o,s,a,c,u,l=r(83),h=r(68),f=Function.prototype.apply,p=Function.prototype.call,d=Object.create,g=Object.defineProperty,b=Object.defineProperties,_=Object.prototype.hasOwnProperty,m={configurable:!0,enumerable:!1,writable:!0};n=function(t,e){var r;return h(e),_.call(this,"__ee__")?r=this.__ee__:(r=m.value=d(null),g(this,"__ee__",m),m.value=null),r[t]?"object"==typeof r[t]?r[t].push(e):r[t]=[r[t],e]:r[t]=e,this},i=function(t,e){var r,i;return h(e),i=this,n.call(this,t,r=function(){o.call(i,t,r),f.call(e,this,arguments)}),r.__eeOnceListener__=e,this},o=function(t,e){var r,n,i,o;if(h(e),!_.call(this,"__ee__"))return this;if(r=this.__ee__,!r[t])return this;if(n=r[t],"object"==typeof n)for(o=0;i=n[o];++o)i!==e&&i.__eeOnceListener__!==e||(2===n.length?r[t]=n[o?0:1]:n.splice(o,1));else n!==e&&n.__eeOnceListener__!==e||delete r[t];return this},s=function(t){var e,r,n,i,o;if(_.call(this,"__ee__")&&(i=this.__ee__[t]))if("object"==typeof i){for(r=arguments.length,o=new Array(r-1),e=1;r>e;++e)o[e-1]=arguments[e];for(i=i.slice(),e=0;n=i[e];++e)f.call(n,this,o)}else switch(arguments.length){case 1:p.call(i,this);break;case 2:p.call(i,this,arguments[1]);break;case 3:p.call(i,this,arguments[1],arguments[2]);break;default:for(r=arguments.length,o=new Array(r-1),e=1;r>e;++e)o[e-1]=arguments[e];f.call(i,this,o)}},a={on:n,once:i,off:o,emit:s},c={on:l(n),once:l(i),off:l(o),emit:l(s)},u=b({},c),t.exports=e=function(t){return null==t?d(u):b(Object(t),c)},e.methods=a},function(t,e,r){"use strict";var n,i=r(90),o=r(68),s=Array.prototype.slice;n=function(t){return this.map(function(e,r){return e?e(t[r]):t[r]}).concat(s.call(t,this.length))},t.exports=function(t){return t=i(t),t.forEach(function(t){null!=t&&o(t)}),n.bind(t)}},function(t,e,r){"use strict";var n=r(91),i=Array.isArray;t.exports=function(t){return i(t)?t:n(t)}},function(t,e,r){"use strict";t.exports=r(92)()?Array.from:r(93)},function(t,e){"use strict";t.exports=function(){var t,e,r=Array.from;return"function"!=typeof r?!1:(t=["raz","dwa"],e=r(t),Boolean(e&&e!==t&&"dwa"===e[1]))}},function(t,e,r){"use strict";var n=r(94).iterator,i=r(99),o=r(100),s=r(62),a=r(68),c=r(71),u=r(102),l=Array.isArray,h=Function.prototype.call,f={configurable:!0,enumerable:!0,writable:!0,value:null},p=Object.defineProperty;t.exports=function(t){var e,r,d,g,b,_,m,y,v,w,x=arguments[1],S=arguments[2];if(t=Object(c(t)),null!=x&&a(x),this&&this!==Array&&o(this))e=this;else{if(!x){if(i(t))return b=t.length,1!==b?Array.apply(null,t):(g=new Array(1),g[0]=t[0],g);if(l(t)){for(g=new Array(b=t.length),r=0;b>r;++r)g[r]=t[r];return g}}g=[]}if(!l(t))if(void 0!==(v=t[n])){for(m=a(v).call(t),e&&(g=new e),y=m.next(),r=0;!y.done;)w=x?h.call(x,S,y.value,r):y.value,e?(f.value=w,p(g,r,f)):g[r]=w,y=m.next(),++r;b=r}else if(u(t)){for(b=t.length,e&&(g=new e),r=0,d=0;b>r;++r)w=t[r],b>r+1&&(_=w.charCodeAt(0),_>=55296&&56319>=_&&(w+=t[++r])),w=x?h.call(x,S,w,d):w,e?(f.value=w,p(g,d,f)):g[d]=w,++d;b=d}if(void 0===b)for(b=s(t.length),e&&(g=new e(b)),r=0;b>r;++r)w=x?h.call(x,S,t[r],r):t[r],e?(f.value=w,p(g,r,f)):g[r]=w;return e&&(f.value=null,g.length=b),g}},function(t,e,r){"use strict";t.exports=r(95)()?Symbol:r(96)},function(t,e){"use strict";t.exports=function(){var t;if("function"!=typeof Symbol)return!1;t=Symbol("test symbol");try{String(t)}catch(e){return!1}return"symbol"==typeof Symbol.iterator?!0:"object"!=typeof Symbol.isConcatSpreadable?!1:"object"!=typeof Symbol.iterator?!1:"object"!=typeof Symbol.toPrimitive?!1:"object"!=typeof Symbol.toStringTag?!1:"object"==typeof Symbol.unscopables}},function(t,e,r){"use strict";var n,i,o,s=r(83),a=r(97),c=Object.create,u=Object.defineProperties,l=Object.defineProperty,h=Object.prototype,f=c(null);"function"==typeof Symbol&&(n=Symbol);var p=function(){var t=c(null);return function(e){for(var r,n,i=0;t[e+(i||"")];)++i;return e+=i||"",t[e]=!0,r="@@"+e,l(h,r,s.gs(null,function(t){n||(n=!0,l(this,r,s(t)),n=!1)})),r}}();o=function(t){if(this instanceof o)throw new TypeError("TypeError: Symbol is not a constructor");return i(t)},t.exports=i=function d(t){var e;if(this instanceof d)throw new TypeError("TypeError: Symbol is not a constructor");return e=c(o.prototype),t=void 0===t?"":String(t),u(e,{__description__:s("",t),__name__:s("",p(t))})},u(i,{"for":s(function(t){return f[t]?f[t]:f[t]=i(String(t))}),keyFor:s(function(t){var e;a(t);for(e in f)if(f[e]===t)return e}),hasInstance:s("",n&&n.hasInstance||i("hasInstance")),isConcatSpreadable:s("",n&&n.isConcatSpreadable||i("isConcatSpreadable")),iterator:s("",n&&n.iterator||i("iterator")),match:s("",n&&n.match||i("match")),replace:s("",n&&n.replace||i("replace")),search:s("",n&&n.search||i("search")),species:s("",n&&n.species||i("species")),split:s("",n&&n.split||i("split")),toPrimitive:s("",n&&n.toPrimitive||i("toPrimitive")),toStringTag:s("",n&&n.toStringTag||i("toStringTag")),unscopables:s("",n&&n.unscopables||i("unscopables"))}),u(o.prototype,{constructor:s(i),toString:s("",function(){return this.__name__})}),u(i.prototype,{toString:s(function(){return"Symbol ("+a(this).__description__+")"}),valueOf:s(function(){return a(this)})}),l(i.prototype,i.toPrimitive,s("",function(){return a(this)})),l(i.prototype,i.toStringTag,s("c","Symbol")),l(o.prototype,i.toStringTag,s("c",i.prototype[i.toStringTag])),l(o.prototype,i.toPrimitive,s("c",i.prototype[i.toPrimitive]))},function(t,e,r){"use strict";var n=r(98);t.exports=function(t){if(!n(t))throw new TypeError(t+" is not a symbol");return t}},function(t,e){"use strict";t.exports=function(t){return t&&("symbol"==typeof t||"Symbol"===t["@@toStringTag"])||!1}},function(t,e){"use strict";var r=Object.prototype.toString,n=r.call(function(){return arguments}());t.exports=function(t){return r.call(t)===n}},function(t,e,r){"use strict";var n=Object.prototype.toString,i=n.call(r(101));t.exports=function(t){return"function"==typeof t&&n.call(t)===i}},function(t,e){"use strict";t.exports=function(){}},function(t,e){"use strict";var r=Object.prototype.toString,n=r.call("");t.exports=function(t){return"string"==typeof t||t&&"object"==typeof t&&(t instanceof String||r.call(t)===n)||!1}},function(t,e,r){"use strict";var n=r(68);t.exports=function(t){var e;return"function"==typeof t?{set:t,get:t}:(e={get:n(t.get)},void 0!==t.set?(e.set=n(t.set),e["delete"]=n(t["delete"]),e.clear=n(t.clear),e):(e.set=e.get,e))}},function(t,e){"use strict";t.exports=function(t){var e,r,n=t.length;if(!n)return"";for(e=String(t[r=0]);--n;)e+="
"+t[++r];return e}},function(t,e){"use strict";t.exports=function(t){return t?function(e){for(var r=String(e[0]),n=0,i=t;--i;)r+="
"+e[++n];return r}:function(){return""}}},function(t,e,r){"use strict";var n=r(107),i=Object.create;t.exports=function(){var t=0,e=[],r=i(null);return{get:function(t){var r,i=0,o=e,s=t.length;if(0===s)return o[s]||null;if(o=o[s]){for(;s-1>i;){if(r=n.call(o[0],t[i]),-1===r)return null;o=o[1][r],++i}return r=n.call(o[0],t[i]),-1===r?null:o[1][r]||null}return null},set:function(i){var o,s=0,a=e,c=i.length;if(0===c)a[c]=++t;else{for(a[c]||(a[c]=[[],[]]),a=a[c];c-1>s;)o=n.call(a[0],i[s]),-1===o&&(o=a[0].push(i[s])-1,a[1].push([[],[]])),a=a[1][o],++s;o=n.call(a[0],i[s]),-1===o&&(o=a[0].push(i[s])-1),a[1][o]=++t}return r[t]=i,t},"delete":function(t){var i,o=0,s=e,a=r[t],c=a.length,u=[];if(0===c)delete s[c];else if(s=s[c]){for(;c-1>o;){if(i=n.call(s[0],a[o]),-1===i)return;u.push(s,i),s=s[1][i],++o}if(i=n.call(s[0],a[o]),-1===i)return;for(t=s[1][i],s[0].splice(i,1),s[1].splice(i,1);!s[0].length&&u.length;)i=u.pop(),s=u.pop(),s[0].splice(i,1),s[1].splice(i,1)}delete r[t]},clear:function(){e=[],r=i(null)}}}},function(t,e,r){"use strict";var n=r(62),i=r(71),o=Array.prototype.indexOf,s=Object.prototype.hasOwnProperty,a=Math.abs,c=Math.floor;t.exports=function(t){var e,r,u,l;if(t===t)return o.apply(this,arguments);for(r=n(i(this).length),u=arguments[1],u=isNaN(u)?0:u>=0?c(u):n(this.length)-c(a(u)),e=u;r>e;++e)if(s.call(this,e)&&(l=this[e],l!==l))return e;return-1}},function(t,e,r){"use strict";var n=r(107);t.exports=function(){var t=0,e=[],r=[];return{get:function(t){var i=n.call(e,t[0]);return-1===i?null:r[i]},set:function(n){return e.push(n[0]),r.push(++t),t},"delete":function(t){var i=n.call(r,t);-1!==i&&(e.splice(i,1),r.splice(i,1))},clear:function(){e=[],r=[]}}}},function(t,e,r){"use strict";var n=r(107),i=Object.create;t.exports=function(t){var e=0,r=[[],[]],o=i(null);return{get:function(e){for(var i,o=0,s=r;t-1>o;){if(i=n.call(s[0],e[o]),-1===i)return null;s=s[1][i],++o}return i=n.call(s[0],e[o]),-1===i?null:s[1][i]||null},set:function(i){for(var s,a=0,c=r;t-1>a;)s=n.call(c[0],i[a]),-1===s&&(s=c[0].push(i[a])-1,c[1].push([[],[]])),c=c[1][s],++a;return s=n.call(c[0],i[a]),-1===s&&(s=c[0].push(i[a])-1),c[1][s]=++e,o[e]=i,e},"delete":function(e){for(var i,s=0,a=r,c=[],u=o[e];t-1>s;){if(i=n.call(a[0],u[s]),-1===i)return;c.push(a,i),a=a[1][i],++s}if(i=n.call(a[0],u[s]),-1!==i){for(e=a[1][i],a[0].splice(i,1),a[1].splice(i,1);!a[0].length&&c.length;)i=c.pop(),a=c.pop(),a[0].splice(i,1),a[1].splice(i,1);delete o[e]}},clear:function(){r=[[],[]],o=i(null)}}}},function(t,e,r){"use strict";var n=r(91),i=r(82),o=r(81),s=r(111),a=Array.prototype.slice,c=Function.prototype.apply,u=Object.create,l=Object.prototype.hasOwnProperty;r(72).async=function(t,e){var r,h,f,p=u(null),d=u(null),g=e.memoized,b=e.original;e.memoized=o(function(t){var e=arguments,n=e[e.length-1];return"function"==typeof n&&(r=n,e=a.call(e,0,-1)),g.apply(h=this,f=e)},g);try{i(e.memoized,g)}catch(_){}e.on("get",function(t){var n,i,o;if(r){if(p[t])return"function"==typeof p[t]?p[t]=[p[t],r]:p[t].push(r),void(r=null);n=r,i=h,o=f,r=h=f=null,s(function(){var s;l.call(d,t)?(s=d[t],e.emit("getasync",t,o,i),c.call(n,s.context,s.args)):(r=n,h=i,f=o,g.apply(i,o))})}}),e.original=function(){var t,i,o,a;return r?(t=n(arguments),i=function u(t){var r,i,o=u.id;return null==o?void s(c.bind(u,this,arguments)):(delete u.id,r=p[o],delete p[o],r?(i=n(arguments),e.has(o)&&(t?e["delete"](o):(d[o]={context:this,args:i},e.emit("setasync",o,"function"==typeof r?1:r.length))),"function"==typeof r?a=c.call(r,this,i):r.forEach(function(t){a=c.call(t,this,i)},this),a):void 0)},o=r,r=h=f=null,t.push(i),a=c.call(b,this,t),i.cb=o,r=i,a):c.call(b,this,arguments)},e.on("set",function(t){return r?(p[t]?"function"==typeof p[t]?p[t]=[p[t],r.cb]:p[t].push(r.cb):p[t]=r.cb,delete r.cb,r.id=t,void(r=null)):void e["delete"](t)}),e.on("delete",function(t){var r;l.call(p,t)||d[t]&&(r=d[t],delete d[t],e.emit("deleteasync",t,r))}),e.on("clear",function(){var t=d;d=u(null),e.emit("clearasync",t)})}},function(t,e,r){(function(e,r){"use strict";var n,i;n=function(t){if("function"!=typeof t)throw new TypeError(t+" is not a function");return t},i=function(t){var e,r=document.createTextNode(""),i=0;return new t(function(){var t;if(e)return t=e,e=null,"function"==typeof t?void t():void t.forEach(function(t){t()})}).observe(r,{characterData:!0}),function(t){return n(t),e?void("function"==typeof e?e=[e,t]:e.push(t)):(e=t,void(r.data=i=++i%2))}},t.exports=function(){if("undefined"!=typeof e&&e&&"function"==typeof e.nextTick)return e.nextTick;if("object"==typeof document&&document){if("function"==typeof MutationObserver)return i(MutationObserver);if("function"==typeof WebKitMutationObserver)return i(WebKitMutationObserver)}return"function"==typeof r?function(t){r(n(t))}:"function"==typeof setTimeout?function(t){setTimeout(n(t),0)}:null}()}).call(e,r(3),r(112).setImmediate)},function(t,e,r){(function(t,n){function i(t,e){this._id=t,this._clearFn=e}var o=r(3).nextTick,s=Function.prototype.apply,a=Array.prototype.slice,c={},u=0;e.setTimeout=function(){return new i(s.call(setTimeout,window,arguments),clearTimeout)},e.setInterval=function(){return new i(s.call(setInterval,window,arguments),clearInterval)},e.clearTimeout=e.clearInterval=function(t){t.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(window,this._id)},e.enroll=function(t,e){clearTimeout(t._idleTimeoutId),t._idleTimeout=e},e.unenroll=function(t){clearTimeout(t._idleTimeoutId),t._idleTimeout=-1},e._unrefActive=e.active=function(t){clearTimeout(t._idleTimeoutId);var e=t._idleTimeout;e>=0&&(t._idleTimeoutId=setTimeout(function(){t._onTimeout&&t._onTimeout()},e))},e.setImmediate="function"==typeof t?t:function(t){var r=u++,n=arguments.length<2?!1:a.call(arguments,1);return c[r]=!0,o(function(){c[r]&&(n?t.apply(null,n):t.call(null),e.clearImmediate(r))}),r},e.clearImmediate="function"==typeof n?n:function(t){delete c[t]}}).call(e,r(112).setImmediate,r(112).clearImmediate)},function(t,e,r){"use strict";var n=r(68),i=r(69),o=r(72),s=Array.prototype.slice,a=Function.prototype.apply;o.dispose=function(t,e,r){var c;return n(t),r.async&&o.async?(e.on("deleteasync",c=function(e,r){a.call(t,null,s.call(r.args,1))}),void e.on("clearasync",function(t){i(t,function(t,e){c(e,t)})})):(e.on("delete",c=function(e,r){t(r)}),void e.on("clear",function(t){i(t,function(t,e){c(e,t)})}))}},function(t,e,r){"use strict";var n=r(91),i=r(101),o=r(69),s=r(115),a=r(72),c=Math.max,u=Math.min,l=Object.create;a.maxAge=function(t,e,r){var h,f,p,d;t=s(t),t&&(h=l(null),f=r.async&&a.async?"async":"",e.on("set"+f,function(r){h[r]=setTimeout(function(){e["delete"](r)},t),d&&(d[r]&&clearTimeout(d[r]),d[r]=setTimeout(function(){delete d[r]},p))}),e.on("delete"+f,function(t){clearTimeout(h[t]),delete h[t],d&&(clearTimeout(d[t]),delete d[t])}),r.preFetch&&(p=r.preFetch===!0||isNaN(r.preFetch)?.333:c(u(Number(r.preFetch),1),0),p&&(d={},p=(1-p)*t,e.on("get"+f,function(t,o,s){d[t]||(d[t]=setTimeout(function(){delete d[t],e["delete"](t),r.async&&(o=n(o),o.push(i)),e.memoized.apply(s,o)},0))}))),e.on("clear"+f,function(){o(h,function(t){clearTimeout(t)}),h={},d&&(o(d,function(t){clearTimeout(t)}),d={})}))}},function(t,e,r){"use strict";var n=r(62),i=r(116);t.exports=function(t){if(t=n(t),t>i)throw new TypeError(t+" exceeds maximum possible timeout");return t}},function(t,e){"use strict";t.exports=2147483647},function(t,e,r){"use strict";var n=r(62),i=r(118),o=r(72);o.max=function(t,e,r){var s,a,c;t=n(t),t&&(a=i(t),s=r.async&&o.async?"async":"",e.on("set"+s,c=function(t){t=a.hit(t),void 0!==t&&e["delete"](t)}),e.on("get"+s,c),e.on("delete"+s,a["delete"]),e.on("clear"+s,a.clear))}},function(t,e,r){"use strict";var n=r(62),i=Object.create,o=Object.prototype.hasOwnProperty;t.exports=function(t){var e,r=0,s=1,a=i(null),c=i(null),u=0;return t=n(t),{hit:function(n){var i=c[n],l=++u;if(a[l]=n,c[n]=l,!i){if(++r,t>=r)return;return n=a[s],e(n),n}if(delete a[i],s===i)for(;!o.call(a,++s);)continue},"delete":e=function(t){var e=c[t];if(e&&(delete a[e],delete c[t],--r,s===e)){if(!r)return u=0,void(s=1);for(;!o.call(a,++s);)continue}},clear:function(){r=0,s=1,a=i(null),c=i(null),u=0}}}},function(t,e,r){"use strict";var n=r(83),i=r(72),o=Object.create,s=Object.defineProperties;i.refCounter=function(t,e,r){var a,c;a=o(null),c=r.async&&i.async?"async":"",e.on("set"+c,function(t,e){a[t]=e||1}),e.on("get"+c,function(t){++a[t]}),e.on("delete"+c,function(t){delete a[t]}),e.on("clear"+c,function(){a={}}),s(e.memoized,{deleteRef:n(function(){var t=e.get(arguments);return null===t?null:a[t]?--a[t]?!1:(e["delete"](t),!0):null}),getRefCount:n(function(){
+var t=e.get(arguments);return null===t?0:a[t]?a[t]:0})})}}]);
\ No newline at end of file
diff --git a/webpack.config.js b/webpack.config.js
index 5a9e1dd8c..6badafd2f 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -9,10 +9,21 @@ module.exports = {
         path: __dirname,
         filename: '[name].js'
     },
+    module: {
+        loaders: [
+            {
+                test: /\.json$/,
+                loader: 'json-loader'
+            }
+        ]
+    },
     plugins: [
         new webpack.optimize.UglifyJsPlugin({
             include: /\.min\.js$/,
-            minimize: true
+            minimize: true,
+            compress: {
+                warnings: false
+            }
         })
     ]
 };