diff --git a/.gitignore b/.gitignore
index 67faecc..221a135 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,6 @@ config/local.json
 
 # Ignore natural lib
 public/libs/natural/
-bower_components
 
 .wav
 audio_stimuli
diff --git a/bower_components/fielddb-glosser/.bower.json b/bower_components/fielddb-glosser/.bower.json
new file mode 100644
index 0000000..30e682b
--- /dev/null
+++ b/bower_components/fielddb-glosser/.bower.json
@@ -0,0 +1,39 @@
+{
+  "name": "fielddb-glosser",
+  "version": "3.12.15",
+  "authors": [
+    "info@fielddb.org"
+  ],
+  "description": "A semi-automatic IGT morpheme segmenter and glosser",
+  "main": "fielddb-glosser.js",
+  "keywords": [
+    "igt",
+    "leipzig",
+    "conventions",
+    "linguistics"
+  ],
+  "license": "Apache 2.0",
+  "homepage": "https://github.com/OpenSourceFieldlinguistics/FieldDB/issues/milestones?state=closed",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "client",
+    "test",
+    "tests",
+    "lib",
+    "dist",
+    "Gruntfile.js",
+    "package.json"
+  ],
+  "dependencies": {},
+  "_release": "3.12.15",
+  "_resolution": {
+    "type": "version",
+    "tag": "v3.12.15",
+    "commit": "1742d71f7c5366041fe78d1eaaba11916ad68781"
+  },
+  "_source": "https://github.com/OpenSourceFieldlinguistics/FieldDBGlosser.git",
+  "_target": "^3.12.15",
+  "_originalSource": "fielddb-glosser"
+}
\ No newline at end of file
diff --git a/bower_components/fielddb-glosser/LICENSE b/bower_components/fielddb-glosser/LICENSE
new file mode 100644
index 0000000..e06d208
--- /dev/null
+++ b/bower_components/fielddb-glosser/LICENSE
@@ -0,0 +1,202 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/bower_components/fielddb-glosser/README.md b/bower_components/fielddb-glosser/README.md
new file mode 100644
index 0000000..9de97b9
--- /dev/null
+++ b/bower_components/fielddb-glosser/README.md
@@ -0,0 +1,123 @@
+# FieldDBGlosser
+
+A semi-automatic IGT morpheme segmenter and glosser
+
+## Getting Started
+### On the server
+Install the module with: `npm install fielddb-glosser --save`
+
+```javascript
+var Glosser = require('FieldDBGlosser').Glosser;
+var glosser = new Glosser("yourdbidentifier"); 
+```
+
+### In the browser
+
+Install the module with: `bower install fielddb-glosser --save`
+
+Or, download the [production version][min] or the [development version][max].
+
+[min]: https://raw.github.com/OpenSourceFieldlinguistics/FieldDBGlosser/master/fielddb-glosser.min.js
+[max]: https://raw.github.com/OpenSourceFieldlinguistics/FieldDBGlosser/master/fielddb-glosser.js
+
+In your web page:
+
+```html
+<script src="bower_components/fielddb-glosser/fielddb-glosser.min.js"></script>
+<script>
+	var glosser = new Glosser("yourdbidentifier"); 
+</script>
+```
+
+
+## Examples
+
+In the examples below, all fields are optional but the more information provided, the more context the glosser can take into account when returning guesses.
+
+
+To guess an utterance (citation line) from morphemes:
+
+```javascript
+glosser.guessUtteranceFromMorphemes({
+	utterance: "",
+	morphemes: "Kicha-nay-wa-n punqo-ta",
+	allomorphs: "",
+	gloss: "open-DES-1OM-3SG door-ACC", 
+	translation: "I feel like opening the door."
+});
+```
+
+
+To guess a morpheme segmention from an utterance/orthography line:
+
+```javascript
+glosser.guessMorphemesFromUtterance({
+	utterance: "Kichanaywan punqota",
+	morphemes: "",
+	allomorphs: "",
+	gloss: "", 
+	translation: "I feel like opening the door."
+});
+```	
+
+
+To guess glosses from a morphemes/allomorphs line:
+
+```javascript
+glosser.guessGlossFromMorphemes({
+	utterance: "Kichanaywan punqota",
+	morphemes: "Kicha-nay-wa-n punqo-ta",
+	allomorphs: "",
+	gloss: "", 
+	translation: "I feel like opening the door."
+});
+```
+
+To show a D3.js force directed graph of morphemes in the corpus:
+
+CSS:
+
+```css
+#corpus-precedence-rules-visualization {
+	background-color: #333;
+	text-align: center;
+}
+
+```
+
+Javascript:
+
+```javascript
+var doubleClickMorpheme = function(dataPoint){
+	console.log("Someone double clicked me ", dataPoint);
+};
+
+try {
+	glosser.visualizeMorphemesAsForceDirectedGraph(null, document.getElementById("corpus-precedence-rules-visualization"), "https://example.com/yourdbidentifier", doubleClickMorpheme);
+} catch(e) {
+	console.warn("There was a problem loading your corpus visualization.");
+}
+```
+
+
+### Sample glosser visualization client code
+
+For source code see [samples/vanilla](https://github.com/OpenSourceFieldlinguistics/FieldDBGlosser/tree/master/samples/vanilla)
+
+
+![lexicon_browser_dashboard](https://f.cloud.github.com/assets/196199/2366164/8555cb70-a6f3-11e3-93ec-140fcaad2294.png)
+
+
+## Contributing
+In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).
+
+_Also, please don't edit files in the "dist" subdirectory as they are generated via Grunt. You'll find source code in the "lib" subdirectory!_
+
+## Release History
+
+* v1.82 Added more functions to the glosser so the client side apps dont have to invent the user experience. Previously the prototype app never overwrote a gloss or morpheme segemetnation if the user had already modified it. But the spread sheet app deleted the users chagnes which was very frustrating. By putting the functionailty in the glosser itself and moving it into a bower component there is a higher chance that this wont happen...
+* v1.16 Basic glosser which uses a map reduce of precedence rules to build a morphemes template, and D3.js visualization of morphemes
+
+## License
+Copyright (c) 2013 FieldDB Contributors
+Licensed under the Apache 2.0 license.
diff --git a/bower_components/fielddb-glosser/bower.json b/bower_components/fielddb-glosser/bower.json
new file mode 100644
index 0000000..ec4779a
--- /dev/null
+++ b/bower_components/fielddb-glosser/bower.json
@@ -0,0 +1,31 @@
+{
+  "name": "fielddb-glosser",
+  "version": "3.12.15",
+  "authors": [
+    "info@fielddb.org"
+  ],
+  "description": "A semi-automatic IGT morpheme segmenter and glosser",
+  "main": "fielddb-glosser.js",
+  "keywords": [
+    "igt",
+    "leipzig",
+    "conventions",
+    "linguistics"
+  ],
+  "license": "Apache 2.0",
+  "homepage": "https://github.com/OpenSourceFieldlinguistics/FieldDB/issues/milestones?state=closed",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "client",
+    "test",
+    "tests",
+    "lib",
+    "dist",
+    "Gruntfile.js",
+    "package.json"
+  ],
+  "dependencies": {
+  }
+}
diff --git a/bower_components/fielddb-glosser/fielddb-glosser.js b/bower_components/fielddb-glosser/fielddb-glosser.js
new file mode 100644
index 0000000..4b531f2
--- /dev/null
+++ b/bower_components/fielddb-glosser/fielddb-glosser.js
@@ -0,0 +1,41193 @@
+/*! fielddb-glosser - v2.2.0 - 2017-03-12
+* https://github.com/OpenSourceFieldlinguistics/FieldDB/issues/milestones?state=closed
+* Copyright (c) 2017 FieldDB Contributors; Licensed Apache 2.0 */
+
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/* globals window, XDomainRequest, XMLHttpRequest, FormData, FieldDB, document */
+"use strict";
+var Q;
+
+try {
+  Q = document.Q || FieldDB.Q;
+} catch (exception) {
+  if (!Q) {
+    Q = require("q");
+  }
+}
+
+var CORS = {
+  OFFLINE: {
+    CODE: 600,
+    MESSAGE: "Unable to contact URL, you appear to be offline."
+  },
+  CLIENT_TIMEOUT: {
+    CODE: 500,
+    MESSAGE: "The request to URL timed out, please try again. If this happens again, please report this."
+  },
+  CONNECTION_ABORTED: {
+    CODE: 500,
+    MESSAGE: "The request to URL was aborted by the server, please report this."
+  },
+  CONNECTION_ERRORED: {
+    CODE: 500,
+    MESSAGE: "Server is not responding for URL, please report this."
+  },
+  INTERNAL_SERVER_ERROR: {
+    CODE: 500
+  },
+  CLIENT_ERROR: {
+    CODE: 400
+  },
+  fieldDBtype: "CORS",
+  timeout: 30 * 1000,
+  debugMode: false,
+  debug: function(a, b, c) {
+    if (this.debugMode) {
+      if (a) {
+        console.log("CORS-DEBUG: " + a);
+      }
+      if (b) {
+        console.log(b);
+      }
+      if (c) {
+        console.log(c);
+      }
+    }
+  },
+  warn: function(message, b, c) {
+    if (this.warnMessage && this.warnMessage.indexOf("message") > -1) {
+      return;
+    } else {
+      this.warnMessage = this.warnMessage + message;
+    }
+    console.warn("CORS-WARN: " + message);
+    if (b) {
+      console.log(b);
+    }
+    if (c) {
+      console.log(c);
+    }
+    // throw message;
+  },
+  bug: function(message) {
+    console.warn("CORS-BUG: " + message);
+  },
+  render: function() {
+    this.debug("Render requested for CORS, but it doesnt know how to render itself.");
+  },
+  clearCookies: function(hostname) {
+    this.warn("TODO clear cookies requested for " + hostname);
+  },
+  preprocess: function(options) {
+    this.debug("\n\n\npreprocess " + options.url + " " + options.complete);
+    options.complete = false;
+    options.percentComplete = 0;
+
+    // this.debugMode = true;
+    if (!options.method) {
+      options.method = options.type || "GET";
+    }
+    if (!options.url) {
+      this.bug("There was an error. Please report this.");
+    }
+    if (!options.data) {
+      options.data = "";
+    }
+    if (options.method === "GET" && options.data) {
+      options.dataToSend = JSON.stringify(options.data).replace(/,/g, "&").replace(/:/g, "=").replace(/"/g, "").replace(/[}{]/g, "");
+      options.url = options.url + "?" + options.dataToSend;
+    }
+  },
+  handleResponse: function(options, deferred) {
+    if (options.complete) {
+      // options = null;
+      return;
+    }
+    this.debug(options.url + " " + options.complete + ":   handleResponse " + options.url);
+
+    var err,
+      status,
+      attr;
+
+    // this.debug("handleResponse", options);
+
+    var response = options.xhr.responseJSON || options.xhr.responseText || options.xhr.response;
+    // this.debug("Response from CORS request to " + options.url + ": " + response);
+
+    try {
+      response = JSON.parse(response);
+    } catch (e) {}
+    if (!response) {
+      response = {};
+    }
+    if (response.reason) {
+      response.message = response.reason;
+      delete response.reason;
+    }
+    status = response.status || options.xhr.status;
+
+    if (status < 400) {
+      this.debug("done " + options.url + " " + options.complete + "\n\n\n");
+      options.complete = true;
+      options.percentComplete = 100;
+      deferred.resolve(response);
+      return;
+    }
+
+    if (typeof response !== "object") {
+      response = {
+        message: response
+      };
+    }
+
+    err = new Error(response.userFriendlyErrors ? response.userFriendlyErrors[0] : response.message);
+    for (attr in response) {
+      if (response.hasOwnProperty(attr)) {
+        err[attr] = response[attr];
+      }
+    }
+    err.status = status;
+
+    this.handleError(options, err, deferred);
+  },
+  handleError: function(options, err, deferred) {
+    if (options.complete) {
+      // options = null;
+      return;
+    }
+    this.debug(options.url + " " + options.complete + ":   handleError " + options.url);
+    var response;
+
+    // this.warn(options.url  + " " +  options.complete + ": was unsuccesful ");
+    this.debug(err.stack);
+
+    response = {
+      userFriendlyErrors: err.userFriendlyErrors || [err.message || "There was an error contacting URL from " + window.location.href + " the app will not function normally. Please report this."],
+      status: err.status || 610,
+      error: err
+    };
+
+    if (response.userFriendlyErrors[0] === "missing") {
+      response.userFriendlyErrors.unshift("The server replied that " + options.url + " is missing, please report this.");
+    } else if (response.userFriendlyErrors[0] === "no_db_file") {
+      response.userFriendlyErrors.unshift("That database doesn't exist. Are you sure this is the database you wanted to open: " + options.url);
+    }
+
+    if (response.status === 401) {
+      if (CORS.application && CORS.application.authentication && CORS.application.authentication.dispatchEvent) {
+        CORS.application.authentication.dispatchEvent("unauthorized");
+      }
+    }
+
+    // Tell the user if they are offline
+    if (response.status >= 500) {
+      try {
+        if (window && window.navigator && !window.navigator.onLine) {
+          response.userFriendlyErrors.unshift(CORS.OFFLINE.MESSAGE);
+          response.status = CORS.OFFLINE.CODE;
+        } else if (err && err.srcElement && err.srcElement.status !== undefined) {
+          response.status = err.srcElement.status;
+        }
+      } catch (e) {}
+    }
+
+    response.userFriendlyErrors[0] = response.userFriendlyErrors[0].replace("URL", options.url);
+    this.bug(response.userFriendlyErrors[0]);
+
+    response.details = options;
+    if (response.details && response.details.xhr) {
+      this.debug(options.url + " " + options.complete + ":  cleaning up ", options.url);
+      options.status = options.status || options.xhr.status;
+      delete options.xhr;
+    }
+    this.debug(options.url + " " + options.complete + ": done " + options.url + "\n\n\n");
+    options.complete = true;
+    deferred.reject(response);
+  },
+  setHeader: function(xhr, key, value) {
+    xhr.setRequestHeader(key, value);
+  },
+  ontimeout: function(options, evt, deferred) {
+    var err = new Error(this.CLIENT_TIMEOUT.MESSAGE);
+    this.debug(options.url + " " + options.complete + ": timed out.");
+
+    err.status = this.CLIENT_TIMEOUT.CODE;
+    this.handleError(options, err, deferred);
+  },
+  onabort: function(options, evt, deferred) {
+    var err = new Error(this.CONNECTION_ABORTED.MESSAGE);
+    this.debug(options.url + " " + options.complete + ": was aborted.");
+
+    err.status = this.CONNECTION_ABORTED.CODE;
+    this.handleError(options, err, deferred);
+  },
+  onerror: function(options, evt, deferred) {
+    var err = new Error(this.CONNECTION_ERRORED.MESSAGE);
+    this.debug(options.url + " " + options.complete + ": errored.");
+
+    if (options.xhr && options.xhr.status) {
+      err.status = options.xhr.status;
+    } else if (options.status) {
+      err.status = options.status;
+    } else {
+      err.status = this.CONNECTION_ERRORED.CODE;
+    }
+
+    this.handleError(options, err, deferred);
+  },
+  onload: function(options, evt, deferred) {
+    this.handleResponse(options, deferred);
+  },
+  onprogress: function(options, evt) {
+    this.debug(options.url + " " + options.complete + ":  onprogress " + options.url + " " + options.complete, evt);
+    if (evt.lengthComputable) {
+      var percentComplete = (evt.loaded / evt.total) * 100;
+      this.debug(options.url + " " + options.complete + ":  percentComplete " + options.url, percentComplete);
+      console.log("Percent complete " + options.url + " : " + percentComplete);
+      if (!options.complete) {
+        options.percentComplete = percentComplete;
+      }
+    }
+    if (options.onprogress && typeof options.onprogress === "function") {
+      options.onprogress(evt);
+    }
+  }
+};
+
+/*
+ * Helper function which handles IE
+ */
+CORS.buildXhr = function(options) {
+  var xhr;
+  try {
+    xhr = new XMLHttpRequest();
+  } catch (e) {
+    this.warn("XMLHttpRequest is not defined, nothing will happen.", e);
+    return null;
+  }
+  if ("withCredentials" in xhr) {
+    // XHR for Chrome/Firefox/Opera/Safari.
+    try {
+      xhr.open(options.method, options.url, true);
+    } catch (exception) {
+      console.log(exception);
+      this.error = exception.message;
+      return null;
+    }
+    // https://mathiasbynens.be/notes/xhr-responsetype-json
+    // xhr.responseType = "json";
+  } else if (typeof XDomainRequest !== "undefined") {
+    // XDomainRequest for IE.
+    xhr = new XDomainRequest();
+    xhr.open(options.method, options.url);
+  } else {
+    // CORS not supported.
+    xhr = null;
+  }
+
+  if (!xhr) {
+    return;
+  }
+
+  this.setHeader(xhr, "Content-type", "application/json");
+  if (options.withCredentials !== false) {
+    xhr.withCredentials = true;
+    // Dont use CORS if its a file
+    if (options.url.lastIndexOf(".") > options.url.lastIndexOf("/") && options.url.substring(options.url.lastIndexOf(".")).indexOf("htm") !== 0) {
+      xhr.withCredentials = false;
+    }
+  }
+
+  if (options.timeout || this.timeout) {
+    xhr.timeout = options.timeout || this.timeout;
+  }
+
+  return xhr;
+};
+
+/*
+ * Functions for well formed CORS requests
+ */
+CORS.makeCORSRequest = function(options) {
+  var self = this,
+    deferred = Q.defer(),
+    data,
+    xhr;
+
+  if (!options || !options.url) {
+    Q.nextTick(function() {
+      deferred.reject({
+        status: 400,
+        details: options,
+        userFriendlyErrors: ["Url must be defined"]
+      });
+    });
+    return deferred.promise;
+  }
+
+  this.preprocess(options, deferred);
+
+  //forcing production server
+  options.url = options.url.replace("corpusdev", "corpus");
+
+  xhr = this.buildXhr(options);
+  if (!xhr) {
+    var message = this.error || "CORS not supported, your device will be unable to contact " + options.url;
+    this.bug(message);
+    Q.nextTick(function() {
+      deferred.reject({
+        status: 620,
+        details: options,
+        userFriendlyErrors: [message]
+      });
+    });
+    return deferred.promise;
+  }
+
+  // If it contains files, make it into a mulitpart upload
+  if (options && options.data && options.data.files) {
+    console.log("converting to formdata ", options.data);
+
+    data = new FormData();
+    for (var part in options.data) {
+      if (options.data.hasOwnProperty(part)) {
+        data.append(part, options.data[part]);
+      }
+    }
+    data = data;
+    this.setHeader(xhr, "Content-Type", "multipart/form-data");
+  } else {
+    if (options.data) {
+      data = JSON.stringify(options.data);
+    }
+  }
+
+  xhr.onprogress = function(evt) {
+    self.onprogress(options, evt, deferred);
+  };
+  xhr.onload = function(evt) {
+    self.onload(options, evt, deferred);
+  };
+  xhr.onerror = function(evt) {
+    self.onerror(options, evt, deferred);
+  };
+  xhr.onabort = function(evt) {
+    self.onabort(options, evt, deferred);
+  };
+  xhr.ontimeout = function(evt) {
+    self.ontimeout(options, evt, deferred);
+  };
+
+  options.xhr = xhr;
+  try {
+    if (data) {
+      self.debug(options.url + " " + options.complete + ": sending ", data);
+      xhr.send(data);
+    } else {
+      xhr.send();
+    }
+  } catch (e) {
+    self.warn("Caught an exception when calling send on xhr", e);
+    e.details = options;
+    deferred.reject(e);
+  }
+
+  return deferred.promise;
+};
+
+try {
+  exports.CORS = CORS;
+} catch (e) {}
+
+try {
+  if (!document) {}
+  // console.log(document);
+} catch (e) {
+  var CORSNode = require("./CORSNode").CORS;
+  console.warn("REST requests: enabled");
+  exports.CORS = CORSNode || CORS;
+}
+
+},{"./CORSNode":2,"q":3}],2:[function(require,module,exports){
+var Q = require("q");
+var http = require("http");
+var https = require("https");
+var url = require("url");
+
+var CORS = require("./CORS").CORS;
+
+/*
+ * Helper function which handles IE
+ */
+CORS.buildXhr = function() {};
+CORS.setHeader = function(xhr, key, value) {
+  xhr.setHeader(key, value);
+};
+
+var COOKIE_JAR = {};
+
+CORS.clearCookies = function(hostname) {
+  if (!hostname) {
+    return;
+  }
+
+  this.warn("clearing cookies on " + hostname);
+  delete COOKIE_JAR[hostname];
+};
+/*
+ * Functions for well formed CORS requests
+ */
+CORS.makeCORSRequest = function(options) {
+  var self = this,
+    deferred = Q.defer(),
+    data = "",
+    xhr;
+
+  if (!options || !options.url) {
+    Q.nextTick(function() {
+      deferred.reject({
+        status: 400,
+        details: options,
+        userFriendlyErrors: ["Url must be defined"]
+      });
+    });
+    return deferred.promise;
+  }
+
+  this.preprocess(options, deferred);
+
+  //forcing production server
+  // options.url = options.url.replace("corpusdev", "corpus");
+  var urlObject = url.parse(options.url);
+
+  var httpOrHttps = http;
+  if (urlObject.protocol === "https:") {
+    httpOrHttps = https;
+    urlObject.port = urlObject.port || 443;
+  }
+  delete urlObject.protocol;
+
+  urlObject.method = options.method || "GET";
+  xhr = httpOrHttps.request(urlObject, function(res) {
+    var output = "";
+    res.setEncoding("utf8");
+
+    self.debug(options.url + " " + options.complete + ":  requesting ");
+
+    res.on("data", function(chunk) {
+      output += chunk;
+      self.debug(options.url + " " + options.complete + ":  ondata ");
+      self.onprogress.apply(self, [options, {
+        lengthComputable: true,
+        loaded: output.length - chunk.length,
+        total: output.length
+      }, deferred]);
+    });
+
+    res.on("end", function() {
+      xhr.responseText = output;
+      xhr.status = res.statusCode;
+
+      // Save cookies
+      if (res.headers && res.headers["set-cookie"]) {
+        COOKIE_JAR[urlObject.host] = res.headers["set-cookie"];
+        self.debug(options.url + " " + options.complete + ": cookies", COOKIE_JAR);
+      }
+
+      // Remove cookies
+      self.debug(options.url + " " + options.complete + ":  response headers " + options.url, res.headers);
+      if (options.method === "DELETE" && urlObject.path === "/_session") {
+        self.clearCookies(urlObject.host);
+      }
+
+      // Final progress event
+      self.onprogress.apply(self, [options, {
+        lengthComputable: true,
+        loaded: output.length,
+        total: output.length
+      }, deferred]);
+
+      self.onload.apply(self, [options, {}, deferred]);
+    });
+  });
+
+  // Include cookies
+  if (COOKIE_JAR[urlObject.host]) {
+    xhr.setHeader("Cookie", COOKIE_JAR[urlObject.host].join(";"));
+  }
+  self.debug(options.url + " " + options.complete + ": request cookies " + xhr.getHeader("cookie"));
+
+  xhr.setHeader("Content-type", "application/json");
+
+  xhr.setTimeout(options.timeout || this.timeout);
+
+  // If it contains files, make it into a mulitpart upload
+  if (options && options.data && options.data.files) {
+    // console.log("converting to formdata ", options.data);
+
+    // data = new FormData();
+    // for (var part in options.data) {
+    //   if (options.data.hasOwnProperty(part)) {
+    //     data.append(part, options.data[part]);
+    //   }
+    // }
+    // data = data;
+    // xhr.setHeader("Content-Type", "multipart/form-data");
+  } else {
+    if (options.data) {
+      data = JSON.stringify(options.data);
+    }
+  }
+
+  xhr.on("error", function(err) {
+    self.onerror.apply(self, [options, err, deferred]);
+  });
+
+  xhr.on("timeout", function(err) {
+    self.ontimeout.apply(self, [options, err, deferred]);
+    xhr.abort();
+  });
+
+  options.xhr = xhr;
+  try {
+    if (data) {
+      self.debug(options.url + " " + options.complete + ": sending ", data);
+      xhr.write(data);
+    } else {
+      xhr.write("");
+    }
+    xhr.end();
+  } catch (e) {
+    self.warn("Caught an exception when calling send on xhr", e.stack);
+    e.details = options;
+    deferred.reject(e);
+  }
+
+  return deferred.promise;
+};
+
+if (exports) {
+  exports.CORS = CORS;
+}
+
+},{"./CORS":1,"http":94,"https":74,"q":3,"url":101}],3:[function(require,module,exports){
+(function (process){
+// vim:ts=4:sts=4:sw=4:
+/*!
+ *
+ * Copyright 2009-2012 Kris Kowal under the terms of the MIT
+ * license found at http://github.com/kriskowal/q/raw/master/LICENSE
+ *
+ * With parts by Tyler Close
+ * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
+ * at http://www.opensource.org/licenses/mit-license.html
+ * Forked at ref_send.js version: 2009-05-11
+ *
+ * With parts by Mark Miller
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (definition) {
+    "use strict";
+
+    // This file will function properly as a <script> tag, or a module
+    // using CommonJS and NodeJS or RequireJS module formats.  In
+    // Common/Node/RequireJS, the module exports the Q API and when
+    // executed as a simple <script>, it creates a Q global instead.
+
+    // Montage Require
+    if (typeof bootstrap === "function") {
+        bootstrap("promise", definition);
+
+    // CommonJS
+    } else if (typeof exports === "object" && typeof module === "object") {
+        module.exports = definition();
+
+    // RequireJS
+    } else if (typeof define === "function" && define.amd) {
+        define(definition);
+
+    // SES (Secure EcmaScript)
+    } else if (typeof ses !== "undefined") {
+        if (!ses.ok()) {
+            return;
+        } else {
+            ses.makeQ = definition;
+        }
+
+    // <script>
+    } else if (typeof window !== "undefined" || typeof self !== "undefined") {
+        // Prefer window over self for add-on scripts. Use self for
+        // non-windowed contexts.
+        var global = typeof window !== "undefined" ? window : self;
+
+        // Get the `window` object, save the previous Q global
+        // and initialize Q as a global.
+        var previousQ = global.Q;
+        global.Q = definition();
+
+        // Add a noConflict function so Q can be removed from the
+        // global namespace.
+        global.Q.noConflict = function () {
+            global.Q = previousQ;
+            return this;
+        };
+
+    } else {
+        throw new Error("This environment was not anticipated by Q. Please file a bug.");
+    }
+
+})(function () {
+"use strict";
+
+var hasStacks = false;
+try {
+    throw new Error();
+} catch (e) {
+    hasStacks = !!e.stack;
+}
+
+// All code after this point will be filtered from stack traces reported
+// by Q.
+var qStartingLine = captureLine();
+var qFileName;
+
+// shims
+
+// used for fallback in "allResolved"
+var noop = function () {};
+
+// Use the fastest possible means to execute a task in a future turn
+// of the event loop.
+var nextTick =(function () {
+    // linked list of tasks (single, with head node)
+    var head = {task: void 0, next: null};
+    var tail = head;
+    var flushing = false;
+    var requestTick = void 0;
+    var isNodeJS = false;
+    // queue for late tasks, used by unhandled rejection tracking
+    var laterQueue = [];
+
+    function flush() {
+        /* jshint loopfunc: true */
+        var task, domain;
+
+        while (head.next) {
+            head = head.next;
+            task = head.task;
+            head.task = void 0;
+            domain = head.domain;
+
+            if (domain) {
+                head.domain = void 0;
+                domain.enter();
+            }
+            runSingle(task, domain);
+
+        }
+        while (laterQueue.length) {
+            task = laterQueue.pop();
+            runSingle(task);
+        }
+        flushing = false;
+    }
+    // runs a single function in the async queue
+    function runSingle(task, domain) {
+        try {
+            task();
+
+        } catch (e) {
+            if (isNodeJS) {
+                // In node, uncaught exceptions are considered fatal errors.
+                // Re-throw them synchronously to interrupt flushing!
+
+                // Ensure continuation if the uncaught exception is suppressed
+                // listening "uncaughtException" events (as domains does).
+                // Continue in next event to avoid tick recursion.
+                if (domain) {
+                    domain.exit();
+                }
+                setTimeout(flush, 0);
+                if (domain) {
+                    domain.enter();
+                }
+
+                throw e;
+
+            } else {
+                // In browsers, uncaught exceptions are not fatal.
+                // Re-throw them asynchronously to avoid slow-downs.
+                setTimeout(function () {
+                    throw e;
+                }, 0);
+            }
+        }
+
+        if (domain) {
+            domain.exit();
+        }
+    }
+
+    nextTick = function (task) {
+        tail = tail.next = {
+            task: task,
+            domain: isNodeJS && process.domain,
+            next: null
+        };
+
+        if (!flushing) {
+            flushing = true;
+            requestTick();
+        }
+    };
+
+    if (typeof process === "object" &&
+        process.toString() === "[object process]" && process.nextTick) {
+        // Ensure Q is in a real Node environment, with a `process.nextTick`.
+        // To see through fake Node environments:
+        // * Mocha test runner - exposes a `process` global without a `nextTick`
+        // * Browserify - exposes a `process.nexTick` function that uses
+        //   `setTimeout`. In this case `setImmediate` is preferred because
+        //    it is faster. Browserify's `process.toString()` yields
+        //   "[object Object]", while in a real Node environment
+        //   `process.nextTick()` yields "[object process]".
+        isNodeJS = true;
+
+        requestTick = function () {
+            process.nextTick(flush);
+        };
+
+    } else if (typeof setImmediate === "function") {
+        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
+        if (typeof window !== "undefined") {
+            requestTick = setImmediate.bind(window, flush);
+        } else {
+            requestTick = function () {
+                setImmediate(flush);
+            };
+        }
+
+    } else if (typeof MessageChannel !== "undefined") {
+        // modern browsers
+        // http://www.nonblocking.io/2011/06/windownexttick.html
+        var channel = new MessageChannel();
+        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
+        // working message ports the first time a page loads.
+        channel.port1.onmessage = function () {
+            requestTick = requestPortTick;
+            channel.port1.onmessage = flush;
+            flush();
+        };
+        var requestPortTick = function () {
+            // Opera requires us to provide a message payload, regardless of
+            // whether we use it.
+            channel.port2.postMessage(0);
+        };
+        requestTick = function () {
+            setTimeout(flush, 0);
+            requestPortTick();
+        };
+
+    } else {
+        // old browsers
+        requestTick = function () {
+            setTimeout(flush, 0);
+        };
+    }
+    // runs a task after all other tasks have been run
+    // this is useful for unhandled rejection tracking that needs to happen
+    // after all `then`d tasks have been run.
+    nextTick.runAfter = function (task) {
+        laterQueue.push(task);
+        if (!flushing) {
+            flushing = true;
+            requestTick();
+        }
+    };
+    return nextTick;
+})();
+
+// Attempt to make generics safe in the face of downstream
+// modifications.
+// There is no situation where this is necessary.
+// If you need a security guarantee, these primordials need to be
+// deeply frozen anyway, and if you don’t need a security guarantee,
+// this is just plain paranoid.
+// However, this **might** have the nice side-effect of reducing the size of
+// the minified code by reducing x.call() to merely x()
+// See Mark Miller’s explanation of what this does.
+// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
+var call = Function.call;
+function uncurryThis(f) {
+    return function () {
+        return call.apply(f, arguments);
+    };
+}
+// This is equivalent, but slower:
+// uncurryThis = Function_bind.bind(Function_bind.call);
+// http://jsperf.com/uncurrythis
+
+var array_slice = uncurryThis(Array.prototype.slice);
+
+var array_reduce = uncurryThis(
+    Array.prototype.reduce || function (callback, basis) {
+        var index = 0,
+            length = this.length;
+        // concerning the initial value, if one is not provided
+        if (arguments.length === 1) {
+            // seek to the first value in the array, accounting
+            // for the possibility that is is a sparse array
+            do {
+                if (index in this) {
+                    basis = this[index++];
+                    break;
+                }
+                if (++index >= length) {
+                    throw new TypeError();
+                }
+            } while (1);
+        }
+        // reduce
+        for (; index < length; index++) {
+            // account for the possibility that the array is sparse
+            if (index in this) {
+                basis = callback(basis, this[index], index);
+            }
+        }
+        return basis;
+    }
+);
+
+var array_indexOf = uncurryThis(
+    Array.prototype.indexOf || function (value) {
+        // not a very good shim, but good enough for our one use of it
+        for (var i = 0; i < this.length; i++) {
+            if (this[i] === value) {
+                return i;
+            }
+        }
+        return -1;
+    }
+);
+
+var array_map = uncurryThis(
+    Array.prototype.map || function (callback, thisp) {
+        var self = this;
+        var collect = [];
+        array_reduce(self, function (undefined, value, index) {
+            collect.push(callback.call(thisp, value, index, self));
+        }, void 0);
+        return collect;
+    }
+);
+
+var object_create = Object.create || function (prototype) {
+    function Type() { }
+    Type.prototype = prototype;
+    return new Type();
+};
+
+var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+
+var object_keys = Object.keys || function (object) {
+    var keys = [];
+    for (var key in object) {
+        if (object_hasOwnProperty(object, key)) {
+            keys.push(key);
+        }
+    }
+    return keys;
+};
+
+var object_toString = uncurryThis(Object.prototype.toString);
+
+function isObject(value) {
+    return value === Object(value);
+}
+
+// generator related shims
+
+// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
+function isStopIteration(exception) {
+    return (
+        object_toString(exception) === "[object StopIteration]" ||
+        exception instanceof QReturnValue
+    );
+}
+
+// FIXME: Remove this helper and Q.return once ES6 generators are in
+// SpiderMonkey.
+var QReturnValue;
+if (typeof ReturnValue !== "undefined") {
+    QReturnValue = ReturnValue;
+} else {
+    QReturnValue = function (value) {
+        this.value = value;
+    };
+}
+
+// long stack traces
+
+var STACK_JUMP_SEPARATOR = "From previous event:";
+
+function makeStackTraceLong(error, promise) {
+    // If possible, transform the error stack trace by removing Node and Q
+    // cruft, then concatenating with the stack trace of `promise`. See #57.
+    if (hasStacks &&
+        promise.stack &&
+        typeof error === "object" &&
+        error !== null &&
+        error.stack &&
+        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
+    ) {
+        var stacks = [];
+        for (var p = promise; !!p; p = p.source) {
+            if (p.stack) {
+                stacks.unshift(p.stack);
+            }
+        }
+        stacks.unshift(error.stack);
+
+        var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
+        error.stack = filterStackString(concatedStacks);
+    }
+}
+
+function filterStackString(stackString) {
+    var lines = stackString.split("\n");
+    var desiredLines = [];
+    for (var i = 0; i < lines.length; ++i) {
+        var line = lines[i];
+
+        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
+            desiredLines.push(line);
+        }
+    }
+    return desiredLines.join("\n");
+}
+
+function isNodeFrame(stackLine) {
+    return stackLine.indexOf("(module.js:") !== -1 ||
+           stackLine.indexOf("(node.js:") !== -1;
+}
+
+function getFileNameAndLineNumber(stackLine) {
+    // Named functions: "at functionName (filename:lineNumber:columnNumber)"
+    // In IE10 function name can have spaces ("Anonymous function") O_o
+    var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
+    if (attempt1) {
+        return [attempt1[1], Number(attempt1[2])];
+    }
+
+    // Anonymous functions: "at filename:lineNumber:columnNumber"
+    var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
+    if (attempt2) {
+        return [attempt2[1], Number(attempt2[2])];
+    }
+
+    // Firefox style: "function@filename:lineNumber or @filename:lineNumber"
+    var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
+    if (attempt3) {
+        return [attempt3[1], Number(attempt3[2])];
+    }
+}
+
+function isInternalFrame(stackLine) {
+    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
+
+    if (!fileNameAndLineNumber) {
+        return false;
+    }
+
+    var fileName = fileNameAndLineNumber[0];
+    var lineNumber = fileNameAndLineNumber[1];
+
+    return fileName === qFileName &&
+        lineNumber >= qStartingLine &&
+        lineNumber <= qEndingLine;
+}
+
+// discover own file name and line number range for filtering stack
+// traces
+function captureLine() {
+    if (!hasStacks) {
+        return;
+    }
+
+    try {
+        throw new Error();
+    } catch (e) {
+        var lines = e.stack.split("\n");
+        var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
+        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
+        if (!fileNameAndLineNumber) {
+            return;
+        }
+
+        qFileName = fileNameAndLineNumber[0];
+        return fileNameAndLineNumber[1];
+    }
+}
+
+function deprecate(callback, name, alternative) {
+    return function () {
+        if (typeof console !== "undefined" &&
+            typeof console.warn === "function") {
+            console.warn(name + " is deprecated, use " + alternative +
+                         " instead.", new Error("").stack);
+        }
+        return callback.apply(callback, arguments);
+    };
+}
+
+// end of shims
+// beginning of real work
+
+/**
+ * Constructs a promise for an immediate reference, passes promises through, or
+ * coerces promises from different systems.
+ * @param value immediate reference or promise
+ */
+function Q(value) {
+    // If the object is already a Promise, return it directly.  This enables
+    // the resolve function to both be used to created references from objects,
+    // but to tolerably coerce non-promises to promises.
+    if (value instanceof Promise) {
+        return value;
+    }
+
+    // assimilate thenables
+    if (isPromiseAlike(value)) {
+        return coerce(value);
+    } else {
+        return fulfill(value);
+    }
+}
+Q.resolve = Q;
+
+/**
+ * Performs a task in a future turn of the event loop.
+ * @param {Function} task
+ */
+Q.nextTick = nextTick;
+
+/**
+ * Controls whether or not long stack traces will be on
+ */
+Q.longStackSupport = false;
+
+// enable long stacks if Q_DEBUG is set
+if (typeof process === "object" && process && process.env && process.env.Q_DEBUG) {
+    Q.longStackSupport = true;
+}
+
+/**
+ * Constructs a {promise, resolve, reject} object.
+ *
+ * `resolve` is a callback to invoke with a more resolved value for the
+ * promise. To fulfill the promise, invoke `resolve` with any value that is
+ * not a thenable. To reject the promise, invoke `resolve` with a rejected
+ * thenable, or invoke `reject` with the reason directly. To resolve the
+ * promise to another thenable, thus putting it in the same state, invoke
+ * `resolve` with that other thenable.
+ */
+Q.defer = defer;
+function defer() {
+    // if "messages" is an "Array", that indicates that the promise has not yet
+    // been resolved.  If it is "undefined", it has been resolved.  Each
+    // element of the messages array is itself an array of complete arguments to
+    // forward to the resolved promise.  We coerce the resolution value to a
+    // promise using the `resolve` function because it handles both fully
+    // non-thenable values and other thenables gracefully.
+    var messages = [], progressListeners = [], resolvedPromise;
+
+    var deferred = object_create(defer.prototype);
+    var promise = object_create(Promise.prototype);
+
+    promise.promiseDispatch = function (resolve, op, operands) {
+        var args = array_slice(arguments);
+        if (messages) {
+            messages.push(args);
+            if (op === "when" && operands[1]) { // progress operand
+                progressListeners.push(operands[1]);
+            }
+        } else {
+            Q.nextTick(function () {
+                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
+            });
+        }
+    };
+
+    // XXX deprecated
+    promise.valueOf = function () {
+        if (messages) {
+            return promise;
+        }
+        var nearerValue = nearer(resolvedPromise);
+        if (isPromise(nearerValue)) {
+            resolvedPromise = nearerValue; // shorten chain
+        }
+        return nearerValue;
+    };
+
+    promise.inspect = function () {
+        if (!resolvedPromise) {
+            return { state: "pending" };
+        }
+        return resolvedPromise.inspect();
+    };
+
+    if (Q.longStackSupport && hasStacks) {
+        try {
+            throw new Error();
+        } catch (e) {
+            // NOTE: don't try to use `Error.captureStackTrace` or transfer the
+            // accessor around; that causes memory leaks as per GH-111. Just
+            // reify the stack trace as a string ASAP.
+            //
+            // At the same time, cut off the first line; it's always just
+            // "[object Promise]\n", as per the `toString`.
+            promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
+        }
+    }
+
+    // NOTE: we do the checks for `resolvedPromise` in each method, instead of
+    // consolidating them into `become`, since otherwise we'd create new
+    // promises with the lines `become(whatever(value))`. See e.g. GH-252.
+
+    function become(newPromise) {
+        resolvedPromise = newPromise;
+        promise.source = newPromise;
+
+        array_reduce(messages, function (undefined, message) {
+            Q.nextTick(function () {
+                newPromise.promiseDispatch.apply(newPromise, message);
+            });
+        }, void 0);
+
+        messages = void 0;
+        progressListeners = void 0;
+    }
+
+    deferred.promise = promise;
+    deferred.resolve = function (value) {
+        if (resolvedPromise) {
+            return;
+        }
+
+        become(Q(value));
+    };
+
+    deferred.fulfill = function (value) {
+        if (resolvedPromise) {
+            return;
+        }
+
+        become(fulfill(value));
+    };
+    deferred.reject = function (reason) {
+        if (resolvedPromise) {
+            return;
+        }
+
+        become(reject(reason));
+    };
+    deferred.notify = function (progress) {
+        if (resolvedPromise) {
+            return;
+        }
+
+        array_reduce(progressListeners, function (undefined, progressListener) {
+            Q.nextTick(function () {
+                progressListener(progress);
+            });
+        }, void 0);
+    };
+
+    return deferred;
+}
+
+/**
+ * Creates a Node-style callback that will resolve or reject the deferred
+ * promise.
+ * @returns a nodeback
+ */
+defer.prototype.makeNodeResolver = function () {
+    var self = this;
+    return function (error, value) {
+        if (error) {
+            self.reject(error);
+        } else if (arguments.length > 2) {
+            self.resolve(array_slice(arguments, 1));
+        } else {
+            self.resolve(value);
+        }
+    };
+};
+
+/**
+ * @param resolver {Function} a function that returns nothing and accepts
+ * the resolve, reject, and notify functions for a deferred.
+ * @returns a promise that may be resolved with the given resolve and reject
+ * functions, or rejected by a thrown exception in resolver
+ */
+Q.Promise = promise; // ES6
+Q.promise = promise;
+function promise(resolver) {
+    if (typeof resolver !== "function") {
+        throw new TypeError("resolver must be a function.");
+    }
+    var deferred = defer();
+    try {
+        resolver(deferred.resolve, deferred.reject, deferred.notify);
+    } catch (reason) {
+        deferred.reject(reason);
+    }
+    return deferred.promise;
+}
+
+promise.race = race; // ES6
+promise.all = all; // ES6
+promise.reject = reject; // ES6
+promise.resolve = Q; // ES6
+
+// XXX experimental.  This method is a way to denote that a local value is
+// serializable and should be immediately dispatched to a remote upon request,
+// instead of passing a reference.
+Q.passByCopy = function (object) {
+    //freeze(object);
+    //passByCopies.set(object, true);
+    return object;
+};
+
+Promise.prototype.passByCopy = function () {
+    //freeze(object);
+    //passByCopies.set(object, true);
+    return this;
+};
+
+/**
+ * If two promises eventually fulfill to the same value, promises that value,
+ * but otherwise rejects.
+ * @param x {Any*}
+ * @param y {Any*}
+ * @returns {Any*} a promise for x and y if they are the same, but a rejection
+ * otherwise.
+ *
+ */
+Q.join = function (x, y) {
+    return Q(x).join(y);
+};
+
+Promise.prototype.join = function (that) {
+    return Q([this, that]).spread(function (x, y) {
+        if (x === y) {
+            // TODO: "===" should be Object.is or equiv
+            return x;
+        } else {
+            throw new Error("Can't join: not the same: " + x + " " + y);
+        }
+    });
+};
+
+/**
+ * Returns a promise for the first of an array of promises to become settled.
+ * @param answers {Array[Any*]} promises to race
+ * @returns {Any*} the first promise to be settled
+ */
+Q.race = race;
+function race(answerPs) {
+    return promise(function (resolve, reject) {
+        // Switch to this once we can assume at least ES5
+        // answerPs.forEach(function (answerP) {
+        //     Q(answerP).then(resolve, reject);
+        // });
+        // Use this in the meantime
+        for (var i = 0, len = answerPs.length; i < len; i++) {
+            Q(answerPs[i]).then(resolve, reject);
+        }
+    });
+}
+
+Promise.prototype.race = function () {
+    return this.then(Q.race);
+};
+
+/**
+ * Constructs a Promise with a promise descriptor object and optional fallback
+ * function.  The descriptor contains methods like when(rejected), get(name),
+ * set(name, value), post(name, args), and delete(name), which all
+ * return either a value, a promise for a value, or a rejection.  The fallback
+ * accepts the operation name, a resolver, and any further arguments that would
+ * have been forwarded to the appropriate method above had a method been
+ * provided with the proper name.  The API makes no guarantees about the nature
+ * of the returned object, apart from that it is usable whereever promises are
+ * bought and sold.
+ */
+Q.makePromise = Promise;
+function Promise(descriptor, fallback, inspect) {
+    if (fallback === void 0) {
+        fallback = function (op) {
+            return reject(new Error(
+                "Promise does not support operation: " + op
+            ));
+        };
+    }
+    if (inspect === void 0) {
+        inspect = function () {
+            return {state: "unknown"};
+        };
+    }
+
+    var promise = object_create(Promise.prototype);
+
+    promise.promiseDispatch = function (resolve, op, args) {
+        var result;
+        try {
+            if (descriptor[op]) {
+                result = descriptor[op].apply(promise, args);
+            } else {
+                result = fallback.call(promise, op, args);
+            }
+        } catch (exception) {
+            result = reject(exception);
+        }
+        if (resolve) {
+            resolve(result);
+        }
+    };
+
+    promise.inspect = inspect;
+
+    // XXX deprecated `valueOf` and `exception` support
+    if (inspect) {
+        var inspected = inspect();
+        if (inspected.state === "rejected") {
+            promise.exception = inspected.reason;
+        }
+
+        promise.valueOf = function () {
+            var inspected = inspect();
+            if (inspected.state === "pending" ||
+                inspected.state === "rejected") {
+                return promise;
+            }
+            return inspected.value;
+        };
+    }
+
+    return promise;
+}
+
+Promise.prototype.toString = function () {
+    return "[object Promise]";
+};
+
+Promise.prototype.then = function (fulfilled, rejected, progressed) {
+    var self = this;
+    var deferred = defer();
+    var done = false;   // ensure the untrusted promise makes at most a
+                        // single call to one of the callbacks
+
+    function _fulfilled(value) {
+        try {
+            return typeof fulfilled === "function" ? fulfilled(value) : value;
+        } catch (exception) {
+            return reject(exception);
+        }
+    }
+
+    function _rejected(exception) {
+        if (typeof rejected === "function") {
+            makeStackTraceLong(exception, self);
+            try {
+                return rejected(exception);
+            } catch (newException) {
+                return reject(newException);
+            }
+        }
+        return reject(exception);
+    }
+
+    function _progressed(value) {
+        return typeof progressed === "function" ? progressed(value) : value;
+    }
+
+    Q.nextTick(function () {
+        self.promiseDispatch(function (value) {
+            if (done) {
+                return;
+            }
+            done = true;
+
+            deferred.resolve(_fulfilled(value));
+        }, "when", [function (exception) {
+            if (done) {
+                return;
+            }
+            done = true;
+
+            deferred.resolve(_rejected(exception));
+        }]);
+    });
+
+    // Progress propagator need to be attached in the current tick.
+    self.promiseDispatch(void 0, "when", [void 0, function (value) {
+        var newValue;
+        var threw = false;
+        try {
+            newValue = _progressed(value);
+        } catch (e) {
+            threw = true;
+            if (Q.onerror) {
+                Q.onerror(e);
+            } else {
+                throw e;
+            }
+        }
+
+        if (!threw) {
+            deferred.notify(newValue);
+        }
+    }]);
+
+    return deferred.promise;
+};
+
+Q.tap = function (promise, callback) {
+    return Q(promise).tap(callback);
+};
+
+/**
+ * Works almost like "finally", but not called for rejections.
+ * Original resolution value is passed through callback unaffected.
+ * Callback may return a promise that will be awaited for.
+ * @param {Function} callback
+ * @returns {Q.Promise}
+ * @example
+ * doSomething()
+ *   .then(...)
+ *   .tap(console.log)
+ *   .then(...);
+ */
+Promise.prototype.tap = function (callback) {
+    callback = Q(callback);
+
+    return this.then(function (value) {
+        return callback.fcall(value).thenResolve(value);
+    });
+};
+
+/**
+ * Registers an observer on a promise.
+ *
+ * Guarantees:
+ *
+ * 1. that fulfilled and rejected will be called only once.
+ * 2. that either the fulfilled callback or the rejected callback will be
+ *    called, but not both.
+ * 3. that fulfilled and rejected will not be called in this turn.
+ *
+ * @param value      promise or immediate reference to observe
+ * @param fulfilled  function to be called with the fulfilled value
+ * @param rejected   function to be called with the rejection exception
+ * @param progressed function to be called on any progress notifications
+ * @return promise for the return value from the invoked callback
+ */
+Q.when = when;
+function when(value, fulfilled, rejected, progressed) {
+    return Q(value).then(fulfilled, rejected, progressed);
+}
+
+Promise.prototype.thenResolve = function (value) {
+    return this.then(function () { return value; });
+};
+
+Q.thenResolve = function (promise, value) {
+    return Q(promise).thenResolve(value);
+};
+
+Promise.prototype.thenReject = function (reason) {
+    return this.then(function () { throw reason; });
+};
+
+Q.thenReject = function (promise, reason) {
+    return Q(promise).thenReject(reason);
+};
+
+/**
+ * If an object is not a promise, it is as "near" as possible.
+ * If a promise is rejected, it is as "near" as possible too.
+ * If it’s a fulfilled promise, the fulfillment value is nearer.
+ * If it’s a deferred promise and the deferred has been resolved, the
+ * resolution is "nearer".
+ * @param object
+ * @returns most resolved (nearest) form of the object
+ */
+
+// XXX should we re-do this?
+Q.nearer = nearer;
+function nearer(value) {
+    if (isPromise(value)) {
+        var inspected = value.inspect();
+        if (inspected.state === "fulfilled") {
+            return inspected.value;
+        }
+    }
+    return value;
+}
+
+/**
+ * @returns whether the given object is a promise.
+ * Otherwise it is a fulfilled value.
+ */
+Q.isPromise = isPromise;
+function isPromise(object) {
+    return object instanceof Promise;
+}
+
+Q.isPromiseAlike = isPromiseAlike;
+function isPromiseAlike(object) {
+    return isObject(object) && typeof object.then === "function";
+}
+
+/**
+ * @returns whether the given object is a pending promise, meaning not
+ * fulfilled or rejected.
+ */
+Q.isPending = isPending;
+function isPending(object) {
+    return isPromise(object) && object.inspect().state === "pending";
+}
+
+Promise.prototype.isPending = function () {
+    return this.inspect().state === "pending";
+};
+
+/**
+ * @returns whether the given object is a value or fulfilled
+ * promise.
+ */
+Q.isFulfilled = isFulfilled;
+function isFulfilled(object) {
+    return !isPromise(object) || object.inspect().state === "fulfilled";
+}
+
+Promise.prototype.isFulfilled = function () {
+    return this.inspect().state === "fulfilled";
+};
+
+/**
+ * @returns whether the given object is a rejected promise.
+ */
+Q.isRejected = isRejected;
+function isRejected(object) {
+    return isPromise(object) && object.inspect().state === "rejected";
+}
+
+Promise.prototype.isRejected = function () {
+    return this.inspect().state === "rejected";
+};
+
+//// BEGIN UNHANDLED REJECTION TRACKING
+
+// This promise library consumes exceptions thrown in handlers so they can be
+// handled by a subsequent promise.  The exceptions get added to this array when
+// they are created, and removed when they are handled.  Note that in ES6 or
+// shimmed environments, this would naturally be a `Set`.
+var unhandledReasons = [];
+var unhandledRejections = [];
+var reportedUnhandledRejections = [];
+var trackUnhandledRejections = true;
+
+function resetUnhandledRejections() {
+    unhandledReasons.length = 0;
+    unhandledRejections.length = 0;
+
+    if (!trackUnhandledRejections) {
+        trackUnhandledRejections = true;
+    }
+}
+
+function trackRejection(promise, reason) {
+    if (!trackUnhandledRejections) {
+        return;
+    }
+    if (typeof process === "object" && typeof process.emit === "function") {
+        Q.nextTick.runAfter(function () {
+            if (array_indexOf(unhandledRejections, promise) !== -1) {
+                process.emit("unhandledRejection", reason, promise);
+                reportedUnhandledRejections.push(promise);
+            }
+        });
+    }
+
+    unhandledRejections.push(promise);
+    if (reason && typeof reason.stack !== "undefined") {
+        unhandledReasons.push(reason.stack);
+    } else {
+        unhandledReasons.push("(no stack) " + reason);
+    }
+}
+
+function untrackRejection(promise) {
+    if (!trackUnhandledRejections) {
+        return;
+    }
+
+    var at = array_indexOf(unhandledRejections, promise);
+    if (at !== -1) {
+        if (typeof process === "object" && typeof process.emit === "function") {
+            Q.nextTick.runAfter(function () {
+                var atReport = array_indexOf(reportedUnhandledRejections, promise);
+                if (atReport !== -1) {
+                    process.emit("rejectionHandled", unhandledReasons[at], promise);
+                    reportedUnhandledRejections.splice(atReport, 1);
+                }
+            });
+        }
+        unhandledRejections.splice(at, 1);
+        unhandledReasons.splice(at, 1);
+    }
+}
+
+Q.resetUnhandledRejections = resetUnhandledRejections;
+
+Q.getUnhandledReasons = function () {
+    // Make a copy so that consumers can't interfere with our internal state.
+    return unhandledReasons.slice();
+};
+
+Q.stopUnhandledRejectionTracking = function () {
+    resetUnhandledRejections();
+    trackUnhandledRejections = false;
+};
+
+resetUnhandledRejections();
+
+//// END UNHANDLED REJECTION TRACKING
+
+/**
+ * Constructs a rejected promise.
+ * @param reason value describing the failure
+ */
+Q.reject = reject;
+function reject(reason) {
+    var rejection = Promise({
+        "when": function (rejected) {
+            // note that the error has been handled
+            if (rejected) {
+                untrackRejection(this);
+            }
+            return rejected ? rejected(reason) : this;
+        }
+    }, function fallback() {
+        return this;
+    }, function inspect() {
+        return { state: "rejected", reason: reason };
+    });
+
+    // Note that the reason has not been handled.
+    trackRejection(rejection, reason);
+
+    return rejection;
+}
+
+/**
+ * Constructs a fulfilled promise for an immediate reference.
+ * @param value immediate reference
+ */
+Q.fulfill = fulfill;
+function fulfill(value) {
+    return Promise({
+        "when": function () {
+            return value;
+        },
+        "get": function (name) {
+            return value[name];
+        },
+        "set": function (name, rhs) {
+            value[name] = rhs;
+        },
+        "delete": function (name) {
+            delete value[name];
+        },
+        "post": function (name, args) {
+            // Mark Miller proposes that post with no name should apply a
+            // promised function.
+            if (name === null || name === void 0) {
+                return value.apply(void 0, args);
+            } else {
+                return value[name].apply(value, args);
+            }
+        },
+        "apply": function (thisp, args) {
+            return value.apply(thisp, args);
+        },
+        "keys": function () {
+            return object_keys(value);
+        }
+    }, void 0, function inspect() {
+        return { state: "fulfilled", value: value };
+    });
+}
+
+/**
+ * Converts thenables to Q promises.
+ * @param promise thenable promise
+ * @returns a Q promise
+ */
+function coerce(promise) {
+    var deferred = defer();
+    Q.nextTick(function () {
+        try {
+            promise.then(deferred.resolve, deferred.reject, deferred.notify);
+        } catch (exception) {
+            deferred.reject(exception);
+        }
+    });
+    return deferred.promise;
+}
+
+/**
+ * Annotates an object such that it will never be
+ * transferred away from this process over any promise
+ * communication channel.
+ * @param object
+ * @returns promise a wrapping of that object that
+ * additionally responds to the "isDef" message
+ * without a rejection.
+ */
+Q.master = master;
+function master(object) {
+    return Promise({
+        "isDef": function () {}
+    }, function fallback(op, args) {
+        return dispatch(object, op, args);
+    }, function () {
+        return Q(object).inspect();
+    });
+}
+
+/**
+ * Spreads the values of a promised array of arguments into the
+ * fulfillment callback.
+ * @param fulfilled callback that receives variadic arguments from the
+ * promised array
+ * @param rejected callback that receives the exception if the promise
+ * is rejected.
+ * @returns a promise for the return value or thrown exception of
+ * either callback.
+ */
+Q.spread = spread;
+function spread(value, fulfilled, rejected) {
+    return Q(value).spread(fulfilled, rejected);
+}
+
+Promise.prototype.spread = function (fulfilled, rejected) {
+    return this.all().then(function (array) {
+        return fulfilled.apply(void 0, array);
+    }, rejected);
+};
+
+/**
+ * The async function is a decorator for generator functions, turning
+ * them into asynchronous generators.  Although generators are only part
+ * of the newest ECMAScript 6 drafts, this code does not cause syntax
+ * errors in older engines.  This code should continue to work and will
+ * in fact improve over time as the language improves.
+ *
+ * ES6 generators are currently part of V8 version 3.19 with the
+ * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
+ * for longer, but under an older Python-inspired form.  This function
+ * works on both kinds of generators.
+ *
+ * Decorates a generator function such that:
+ *  - it may yield promises
+ *  - execution will continue when that promise is fulfilled
+ *  - the value of the yield expression will be the fulfilled value
+ *  - it returns a promise for the return value (when the generator
+ *    stops iterating)
+ *  - the decorated function returns a promise for the return value
+ *    of the generator or the first rejected promise among those
+ *    yielded.
+ *  - if an error is thrown in the generator, it propagates through
+ *    every following yield until it is caught, or until it escapes
+ *    the generator function altogether, and is translated into a
+ *    rejection for the promise returned by the decorated generator.
+ */
+Q.async = async;
+function async(makeGenerator) {
+    return function () {
+        // when verb is "send", arg is a value
+        // when verb is "throw", arg is an exception
+        function continuer(verb, arg) {
+            var result;
+
+            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
+            // engine that has a deployed base of browsers that support generators.
+            // However, SM's generators use the Python-inspired semantics of
+            // outdated ES6 drafts.  We would like to support ES6, but we'd also
+            // like to make it possible to use generators in deployed browsers, so
+            // we also support Python-style generators.  At some point we can remove
+            // this block.
+
+            if (typeof StopIteration === "undefined") {
+                // ES6 Generators
+                try {
+                    result = generator[verb](arg);
+                } catch (exception) {
+                    return reject(exception);
+                }
+                if (result.done) {
+                    return Q(result.value);
+                } else {
+                    return when(result.value, callback, errback);
+                }
+            } else {
+                // SpiderMonkey Generators
+                // FIXME: Remove this case when SM does ES6 generators.
+                try {
+                    result = generator[verb](arg);
+                } catch (exception) {
+                    if (isStopIteration(exception)) {
+                        return Q(exception.value);
+                    } else {
+                        return reject(exception);
+                    }
+                }
+                return when(result, callback, errback);
+            }
+        }
+        var generator = makeGenerator.apply(this, arguments);
+        var callback = continuer.bind(continuer, "next");
+        var errback = continuer.bind(continuer, "throw");
+        return callback();
+    };
+}
+
+/**
+ * The spawn function is a small wrapper around async that immediately
+ * calls the generator and also ends the promise chain, so that any
+ * unhandled errors are thrown instead of forwarded to the error
+ * handler. This is useful because it's extremely common to run
+ * generators at the top-level to work with libraries.
+ */
+Q.spawn = spawn;
+function spawn(makeGenerator) {
+    Q.done(Q.async(makeGenerator)());
+}
+
+// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
+/**
+ * Throws a ReturnValue exception to stop an asynchronous generator.
+ *
+ * This interface is a stop-gap measure to support generator return
+ * values in older Firefox/SpiderMonkey.  In browsers that support ES6
+ * generators like Chromium 29, just use "return" in your generator
+ * functions.
+ *
+ * @param value the return value for the surrounding generator
+ * @throws ReturnValue exception with the value.
+ * @example
+ * // ES6 style
+ * Q.async(function* () {
+ *      var foo = yield getFooPromise();
+ *      var bar = yield getBarPromise();
+ *      return foo + bar;
+ * })
+ * // Older SpiderMonkey style
+ * Q.async(function () {
+ *      var foo = yield getFooPromise();
+ *      var bar = yield getBarPromise();
+ *      Q.return(foo + bar);
+ * })
+ */
+Q["return"] = _return;
+function _return(value) {
+    throw new QReturnValue(value);
+}
+
+/**
+ * The promised function decorator ensures that any promise arguments
+ * are settled and passed as values (`this` is also settled and passed
+ * as a value).  It will also ensure that the result of a function is
+ * always a promise.
+ *
+ * @example
+ * var add = Q.promised(function (a, b) {
+ *     return a + b;
+ * });
+ * add(Q(a), Q(B));
+ *
+ * @param {function} callback The function to decorate
+ * @returns {function} a function that has been decorated.
+ */
+Q.promised = promised;
+function promised(callback) {
+    return function () {
+        return spread([this, all(arguments)], function (self, args) {
+            return callback.apply(self, args);
+        });
+    };
+}
+
+/**
+ * sends a message to a value in a future turn
+ * @param object* the recipient
+ * @param op the name of the message operation, e.g., "when",
+ * @param args further arguments to be forwarded to the operation
+ * @returns result {Promise} a promise for the result of the operation
+ */
+Q.dispatch = dispatch;
+function dispatch(object, op, args) {
+    return Q(object).dispatch(op, args);
+}
+
+Promise.prototype.dispatch = function (op, args) {
+    var self = this;
+    var deferred = defer();
+    Q.nextTick(function () {
+        self.promiseDispatch(deferred.resolve, op, args);
+    });
+    return deferred.promise;
+};
+
+/**
+ * Gets the value of a property in a future turn.
+ * @param object    promise or immediate reference for target object
+ * @param name      name of property to get
+ * @return promise for the property value
+ */
+Q.get = function (object, key) {
+    return Q(object).dispatch("get", [key]);
+};
+
+Promise.prototype.get = function (key) {
+    return this.dispatch("get", [key]);
+};
+
+/**
+ * Sets the value of a property in a future turn.
+ * @param object    promise or immediate reference for object object
+ * @param name      name of property to set
+ * @param value     new value of property
+ * @return promise for the return value
+ */
+Q.set = function (object, key, value) {
+    return Q(object).dispatch("set", [key, value]);
+};
+
+Promise.prototype.set = function (key, value) {
+    return this.dispatch("set", [key, value]);
+};
+
+/**
+ * Deletes a property in a future turn.
+ * @param object    promise or immediate reference for target object
+ * @param name      name of property to delete
+ * @return promise for the return value
+ */
+Q.del = // XXX legacy
+Q["delete"] = function (object, key) {
+    return Q(object).dispatch("delete", [key]);
+};
+
+Promise.prototype.del = // XXX legacy
+Promise.prototype["delete"] = function (key) {
+    return this.dispatch("delete", [key]);
+};
+
+/**
+ * Invokes a method in a future turn.
+ * @param object    promise or immediate reference for target object
+ * @param name      name of method to invoke
+ * @param value     a value to post, typically an array of
+ *                  invocation arguments for promises that
+ *                  are ultimately backed with `resolve` values,
+ *                  as opposed to those backed with URLs
+ *                  wherein the posted value can be any
+ *                  JSON serializable object.
+ * @return promise for the return value
+ */
+// bound locally because it is used by other methods
+Q.mapply = // XXX As proposed by "Redsandro"
+Q.post = function (object, name, args) {
+    return Q(object).dispatch("post", [name, args]);
+};
+
+Promise.prototype.mapply = // XXX As proposed by "Redsandro"
+Promise.prototype.post = function (name, args) {
+    return this.dispatch("post", [name, args]);
+};
+
+/**
+ * Invokes a method in a future turn.
+ * @param object    promise or immediate reference for target object
+ * @param name      name of method to invoke
+ * @param ...args   array of invocation arguments
+ * @return promise for the return value
+ */
+Q.send = // XXX Mark Miller's proposed parlance
+Q.mcall = // XXX As proposed by "Redsandro"
+Q.invoke = function (object, name /*...args*/) {
+    return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
+};
+
+Promise.prototype.send = // XXX Mark Miller's proposed parlance
+Promise.prototype.mcall = // XXX As proposed by "Redsandro"
+Promise.prototype.invoke = function (name /*...args*/) {
+    return this.dispatch("post", [name, array_slice(arguments, 1)]);
+};
+
+/**
+ * Applies the promised function in a future turn.
+ * @param object    promise or immediate reference for target function
+ * @param args      array of application arguments
+ */
+Q.fapply = function (object, args) {
+    return Q(object).dispatch("apply", [void 0, args]);
+};
+
+Promise.prototype.fapply = function (args) {
+    return this.dispatch("apply", [void 0, args]);
+};
+
+/**
+ * Calls the promised function in a future turn.
+ * @param object    promise or immediate reference for target function
+ * @param ...args   array of application arguments
+ */
+Q["try"] =
+Q.fcall = function (object /* ...args*/) {
+    return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
+};
+
+Promise.prototype.fcall = function (/*...args*/) {
+    return this.dispatch("apply", [void 0, array_slice(arguments)]);
+};
+
+/**
+ * Binds the promised function, transforming return values into a fulfilled
+ * promise and thrown errors into a rejected one.
+ * @param object    promise or immediate reference for target function
+ * @param ...args   array of application arguments
+ */
+Q.fbind = function (object /*...args*/) {
+    var promise = Q(object);
+    var args = array_slice(arguments, 1);
+    return function fbound() {
+        return promise.dispatch("apply", [
+            this,
+            args.concat(array_slice(arguments))
+        ]);
+    };
+};
+Promise.prototype.fbind = function (/*...args*/) {
+    var promise = this;
+    var args = array_slice(arguments);
+    return function fbound() {
+        return promise.dispatch("apply", [
+            this,
+            args.concat(array_slice(arguments))
+        ]);
+    };
+};
+
+/**
+ * Requests the names of the owned properties of a promised
+ * object in a future turn.
+ * @param object    promise or immediate reference for target object
+ * @return promise for the keys of the eventually settled object
+ */
+Q.keys = function (object) {
+    return Q(object).dispatch("keys", []);
+};
+
+Promise.prototype.keys = function () {
+    return this.dispatch("keys", []);
+};
+
+/**
+ * Turns an array of promises into a promise for an array.  If any of
+ * the promises gets rejected, the whole array is rejected immediately.
+ * @param {Array*} an array (or promise for an array) of values (or
+ * promises for values)
+ * @returns a promise for an array of the corresponding values
+ */
+// By Mark Miller
+// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
+Q.all = all;
+function all(promises) {
+    return when(promises, function (promises) {
+        var pendingCount = 0;
+        var deferred = defer();
+        array_reduce(promises, function (undefined, promise, index) {
+            var snapshot;
+            if (
+                isPromise(promise) &&
+                (snapshot = promise.inspect()).state === "fulfilled"
+            ) {
+                promises[index] = snapshot.value;
+            } else {
+                ++pendingCount;
+                when(
+                    promise,
+                    function (value) {
+                        promises[index] = value;
+                        if (--pendingCount === 0) {
+                            deferred.resolve(promises);
+                        }
+                    },
+                    deferred.reject,
+                    function (progress) {
+                        deferred.notify({ index: index, value: progress });
+                    }
+                );
+            }
+        }, void 0);
+        if (pendingCount === 0) {
+            deferred.resolve(promises);
+        }
+        return deferred.promise;
+    });
+}
+
+Promise.prototype.all = function () {
+    return all(this);
+};
+
+/**
+ * Returns the first resolved promise of an array. Prior rejected promises are
+ * ignored.  Rejects only if all promises are rejected.
+ * @param {Array*} an array containing values or promises for values
+ * @returns a promise fulfilled with the value of the first resolved promise,
+ * or a rejected promise if all promises are rejected.
+ */
+Q.any = any;
+
+function any(promises) {
+    if (promises.length === 0) {
+        return Q.resolve();
+    }
+
+    var deferred = Q.defer();
+    var pendingCount = 0;
+    array_reduce(promises, function (prev, current, index) {
+        var promise = promises[index];
+
+        pendingCount++;
+
+        when(promise, onFulfilled, onRejected, onProgress);
+        function onFulfilled(result) {
+            deferred.resolve(result);
+        }
+        function onRejected() {
+            pendingCount--;
+            if (pendingCount === 0) {
+                deferred.reject(new Error(
+                    "Can't get fulfillment value from any promise, all " +
+                    "promises were rejected."
+                ));
+            }
+        }
+        function onProgress(progress) {
+            deferred.notify({
+                index: index,
+                value: progress
+            });
+        }
+    }, undefined);
+
+    return deferred.promise;
+}
+
+Promise.prototype.any = function () {
+    return any(this);
+};
+
+/**
+ * Waits for all promises to be settled, either fulfilled or
+ * rejected.  This is distinct from `all` since that would stop
+ * waiting at the first rejection.  The promise returned by
+ * `allResolved` will never be rejected.
+ * @param promises a promise for an array (or an array) of promises
+ * (or values)
+ * @return a promise for an array of promises
+ */
+Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
+function allResolved(promises) {
+    return when(promises, function (promises) {
+        promises = array_map(promises, Q);
+        return when(all(array_map(promises, function (promise) {
+            return when(promise, noop, noop);
+        })), function () {
+            return promises;
+        });
+    });
+}
+
+Promise.prototype.allResolved = function () {
+    return allResolved(this);
+};
+
+/**
+ * @see Promise#allSettled
+ */
+Q.allSettled = allSettled;
+function allSettled(promises) {
+    return Q(promises).allSettled();
+}
+
+/**
+ * Turns an array of promises into a promise for an array of their states (as
+ * returned by `inspect`) when they have all settled.
+ * @param {Array[Any*]} values an array (or promise for an array) of values (or
+ * promises for values)
+ * @returns {Array[State]} an array of states for the respective values.
+ */
+Promise.prototype.allSettled = function () {
+    return this.then(function (promises) {
+        return all(array_map(promises, function (promise) {
+            promise = Q(promise);
+            function regardless() {
+                return promise.inspect();
+            }
+            return promise.then(regardless, regardless);
+        }));
+    });
+};
+
+/**
+ * Captures the failure of a promise, giving an oportunity to recover
+ * with a callback.  If the given promise is fulfilled, the returned
+ * promise is fulfilled.
+ * @param {Any*} promise for something
+ * @param {Function} callback to fulfill the returned promise if the
+ * given promise is rejected
+ * @returns a promise for the return value of the callback
+ */
+Q.fail = // XXX legacy
+Q["catch"] = function (object, rejected) {
+    return Q(object).then(void 0, rejected);
+};
+
+Promise.prototype.fail = // XXX legacy
+Promise.prototype["catch"] = function (rejected) {
+    return this.then(void 0, rejected);
+};
+
+/**
+ * Attaches a listener that can respond to progress notifications from a
+ * promise's originating deferred. This listener receives the exact arguments
+ * passed to ``deferred.notify``.
+ * @param {Any*} promise for something
+ * @param {Function} callback to receive any progress notifications
+ * @returns the given promise, unchanged
+ */
+Q.progress = progress;
+function progress(object, progressed) {
+    return Q(object).then(void 0, void 0, progressed);
+}
+
+Promise.prototype.progress = function (progressed) {
+    return this.then(void 0, void 0, progressed);
+};
+
+/**
+ * Provides an opportunity to observe the settling of a promise,
+ * regardless of whether the promise is fulfilled or rejected.  Forwards
+ * the resolution to the returned promise when the callback is done.
+ * The callback can return a promise to defer completion.
+ * @param {Any*} promise
+ * @param {Function} callback to observe the resolution of the given
+ * promise, takes no arguments.
+ * @returns a promise for the resolution of the given promise when
+ * ``fin`` is done.
+ */
+Q.fin = // XXX legacy
+Q["finally"] = function (object, callback) {
+    return Q(object)["finally"](callback);
+};
+
+Promise.prototype.fin = // XXX legacy
+Promise.prototype["finally"] = function (callback) {
+    callback = Q(callback);
+    return this.then(function (value) {
+        return callback.fcall().then(function () {
+            return value;
+        });
+    }, function (reason) {
+        // TODO attempt to recycle the rejection with "this".
+        return callback.fcall().then(function () {
+            throw reason;
+        });
+    });
+};
+
+/**
+ * Terminates a chain of promises, forcing rejections to be
+ * thrown as exceptions.
+ * @param {Any*} promise at the end of a chain of promises
+ * @returns nothing
+ */
+Q.done = function (object, fulfilled, rejected, progress) {
+    return Q(object).done(fulfilled, rejected, progress);
+};
+
+Promise.prototype.done = function (fulfilled, rejected, progress) {
+    var onUnhandledError = function (error) {
+        // forward to a future turn so that ``when``
+        // does not catch it and turn it into a rejection.
+        Q.nextTick(function () {
+            makeStackTraceLong(error, promise);
+            if (Q.onerror) {
+                Q.onerror(error);
+            } else {
+                throw error;
+            }
+        });
+    };
+
+    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.
+    var promise = fulfilled || rejected || progress ?
+        this.then(fulfilled, rejected, progress) :
+        this;
+
+    if (typeof process === "object" && process && process.domain) {
+        onUnhandledError = process.domain.bind(onUnhandledError);
+    }
+
+    promise.then(void 0, onUnhandledError);
+};
+
+/**
+ * Causes a promise to be rejected if it does not get fulfilled before
+ * some milliseconds time out.
+ * @param {Any*} promise
+ * @param {Number} milliseconds timeout
+ * @param {Any*} custom error message or Error object (optional)
+ * @returns a promise for the resolution of the given promise if it is
+ * fulfilled before the timeout, otherwise rejected.
+ */
+Q.timeout = function (object, ms, error) {
+    return Q(object).timeout(ms, error);
+};
+
+Promise.prototype.timeout = function (ms, error) {
+    var deferred = defer();
+    var timeoutId = setTimeout(function () {
+        if (!error || "string" === typeof error) {
+            error = new Error(error || "Timed out after " + ms + " ms");
+            error.code = "ETIMEDOUT";
+        }
+        deferred.reject(error);
+    }, ms);
+
+    this.then(function (value) {
+        clearTimeout(timeoutId);
+        deferred.resolve(value);
+    }, function (exception) {
+        clearTimeout(timeoutId);
+        deferred.reject(exception);
+    }, deferred.notify);
+
+    return deferred.promise;
+};
+
+/**
+ * Returns a promise for the given value (or promised value), some
+ * milliseconds after it resolved. Passes rejections immediately.
+ * @param {Any*} promise
+ * @param {Number} milliseconds
+ * @returns a promise for the resolution of the given promise after milliseconds
+ * time has elapsed since the resolution of the given promise.
+ * If the given promise rejects, that is passed immediately.
+ */
+Q.delay = function (object, timeout) {
+    if (timeout === void 0) {
+        timeout = object;
+        object = void 0;
+    }
+    return Q(object).delay(timeout);
+};
+
+Promise.prototype.delay = function (timeout) {
+    return this.then(function (value) {
+        var deferred = defer();
+        setTimeout(function () {
+            deferred.resolve(value);
+        }, timeout);
+        return deferred.promise;
+    });
+};
+
+/**
+ * Passes a continuation to a Node function, which is called with the given
+ * arguments provided as an array, and returns a promise.
+ *
+ *      Q.nfapply(FS.readFile, [__filename])
+ *      .then(function (content) {
+ *      })
+ *
+ */
+Q.nfapply = function (callback, args) {
+    return Q(callback).nfapply(args);
+};
+
+Promise.prototype.nfapply = function (args) {
+    var deferred = defer();
+    var nodeArgs = array_slice(args);
+    nodeArgs.push(deferred.makeNodeResolver());
+    this.fapply(nodeArgs).fail(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * Passes a continuation to a Node function, which is called with the given
+ * arguments provided individually, and returns a promise.
+ * @example
+ * Q.nfcall(FS.readFile, __filename)
+ * .then(function (content) {
+ * })
+ *
+ */
+Q.nfcall = function (callback /*...args*/) {
+    var args = array_slice(arguments, 1);
+    return Q(callback).nfapply(args);
+};
+
+Promise.prototype.nfcall = function (/*...args*/) {
+    var nodeArgs = array_slice(arguments);
+    var deferred = defer();
+    nodeArgs.push(deferred.makeNodeResolver());
+    this.fapply(nodeArgs).fail(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * Wraps a NodeJS continuation passing function and returns an equivalent
+ * version that returns a promise.
+ * @example
+ * Q.nfbind(FS.readFile, __filename)("utf-8")
+ * .then(console.log)
+ * .done()
+ */
+Q.nfbind =
+Q.denodeify = function (callback /*...args*/) {
+    var baseArgs = array_slice(arguments, 1);
+    return function () {
+        var nodeArgs = baseArgs.concat(array_slice(arguments));
+        var deferred = defer();
+        nodeArgs.push(deferred.makeNodeResolver());
+        Q(callback).fapply(nodeArgs).fail(deferred.reject);
+        return deferred.promise;
+    };
+};
+
+Promise.prototype.nfbind =
+Promise.prototype.denodeify = function (/*...args*/) {
+    var args = array_slice(arguments);
+    args.unshift(this);
+    return Q.denodeify.apply(void 0, args);
+};
+
+Q.nbind = function (callback, thisp /*...args*/) {
+    var baseArgs = array_slice(arguments, 2);
+    return function () {
+        var nodeArgs = baseArgs.concat(array_slice(arguments));
+        var deferred = defer();
+        nodeArgs.push(deferred.makeNodeResolver());
+        function bound() {
+            return callback.apply(thisp, arguments);
+        }
+        Q(bound).fapply(nodeArgs).fail(deferred.reject);
+        return deferred.promise;
+    };
+};
+
+Promise.prototype.nbind = function (/*thisp, ...args*/) {
+    var args = array_slice(arguments, 0);
+    args.unshift(this);
+    return Q.nbind.apply(void 0, args);
+};
+
+/**
+ * Calls a method of a Node-style object that accepts a Node-style
+ * callback with a given array of arguments, plus a provided callback.
+ * @param object an object that has the named method
+ * @param {String} name name of the method of object
+ * @param {Array} args arguments to pass to the method; the callback
+ * will be provided by Q and appended to these arguments.
+ * @returns a promise for the value or error
+ */
+Q.nmapply = // XXX As proposed by "Redsandro"
+Q.npost = function (object, name, args) {
+    return Q(object).npost(name, args);
+};
+
+Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
+Promise.prototype.npost = function (name, args) {
+    var nodeArgs = array_slice(args || []);
+    var deferred = defer();
+    nodeArgs.push(deferred.makeNodeResolver());
+    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * Calls a method of a Node-style object that accepts a Node-style
+ * callback, forwarding the given variadic arguments, plus a provided
+ * callback argument.
+ * @param object an object that has the named method
+ * @param {String} name name of the method of object
+ * @param ...args arguments to pass to the method; the callback will
+ * be provided by Q and appended to these arguments.
+ * @returns a promise for the value or error
+ */
+Q.nsend = // XXX Based on Mark Miller's proposed "send"
+Q.nmcall = // XXX Based on "Redsandro's" proposal
+Q.ninvoke = function (object, name /*...args*/) {
+    var nodeArgs = array_slice(arguments, 2);
+    var deferred = defer();
+    nodeArgs.push(deferred.makeNodeResolver());
+    Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
+    return deferred.promise;
+};
+
+Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
+Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
+Promise.prototype.ninvoke = function (name /*...args*/) {
+    var nodeArgs = array_slice(arguments, 1);
+    var deferred = defer();
+    nodeArgs.push(deferred.makeNodeResolver());
+    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * If a function would like to support both Node continuation-passing-style and
+ * promise-returning-style, it can end its internal promise chain with
+ * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
+ * elects to use a nodeback, the result will be sent there.  If they do not
+ * pass a nodeback, they will receive the result promise.
+ * @param object a result (or a promise for a result)
+ * @param {Function} nodeback a Node.js-style callback
+ * @returns either the promise or nothing
+ */
+Q.nodeify = nodeify;
+function nodeify(object, nodeback) {
+    return Q(object).nodeify(nodeback);
+}
+
+Promise.prototype.nodeify = function (nodeback) {
+    if (nodeback) {
+        this.then(function (value) {
+            Q.nextTick(function () {
+                nodeback(null, value);
+            });
+        }, function (error) {
+            Q.nextTick(function () {
+                nodeback(error);
+            });
+        });
+    } else {
+        return this;
+    }
+};
+
+Q.noConflict = function() {
+    throw new Error("Q.noConflict only works when Q is used as a global");
+};
+
+// All code before this point will be filtered from stack traces.
+var qEndingLine = captureLine();
+
+return Q;
+
+});
+
+}).call(this,require('_process'))
+},{"_process":77}],4:[function(require,module,exports){
+(function (global){
+var d3 = d3 || require("d3");
+var _ = _ || require("underscore");
+var LexiconFactory = require("./Lexicon").LexiconFactory;
+
+/*
+ * FieldDBGlosser
+ * https://github.com/OpenSourceFieldlinguistics/FieldDB/issues/milestones?state=closed
+ *
+ * Copyright (c) 2013 FieldDB contributors
+ * Licensed under the Apache 2.0 license.
+ */
+(function(exports) {
+
+  'use strict';
+
+  var Glosser = function(options) {
+    var XMLHttpRequestLocal;
+
+    // let XMLHttpRequestLocal be injected
+    if (options && options.XMLHttpRequestLocal) {
+      XMLHttpRequestLocal = options.XMLHttpRequestLocal;
+    } else {
+      XMLHttpRequestLocal = window.XMLHttpRequest;
+    }
+    for (var attribute in options) {
+      if (!options.hasOwnProperty(attribute)) {
+        continue;
+      }
+      this[attribute] = options[attribute];
+    }
+
+    // var console = console || {
+    //   log: function() {}
+    // };
+    var OPrime = OPrime || {
+      debugMode: true,
+      bug: function(message) {
+        console.log(message);
+      },
+      debug: function(message, message2, message3, message4) {
+        if (this.debugMode) {
+          console.log(message);
+
+          if (message2) {
+            console.log(message2);
+          }
+          if (message3) {
+            console.log(message3);
+          }
+          if (message4) {
+            console.log(message4);
+          }
+        }
+      },
+      makeCORSRequest: function(options) {
+        OPrime.debugMode = false;
+        if (!options.method) {
+          options.method = options.type || "GET";
+        }
+        if (!options.url) {
+          OPrime.bug("There was an error. Please report this.");
+        }
+        if (!options.data) {
+          options.data = "";
+        }
+        options.dataToSend = JSON.stringify(options.data).replace(/,/g, "&").replace(/:/g, "=").replace(/"/g, "").replace(/[}{]/g, "");
+
+        if (options.method === "GET" && options.data) {
+          options.url = options.url + "?" + options.dataToSend;
+        }
+        /*
+         * Helper function which handles IE
+         */
+        var createCORSRequest = function(method, url) {
+          var xhr = new XMLHttpRequestLocal();
+          if ("withCredentials" in xhr) {
+            // XHR for Chrome/Firefox/Opera/Safari.
+            xhr.open(method, url, true);
+          } else if (typeof XDomainRequest !== "undefined") {
+            // XDomainRequest for IE.
+            xhr = new XDomainRequest();
+            xhr.open(method, url);
+          } else {
+            // CORS not supported.
+            xhr = null;
+          }
+          return xhr;
+        };
+
+        var xhr = createCORSRequest(options.method, options.url);
+        if (!xhr) {
+          OPrime.bug('CORS not supported, your browser is unable to contact the database.');
+          return;
+        }
+
+        //  if(options.method === "POST"){
+        //xhr.setRequestHeader("Content-type","application/x-www-form-urlencoded");
+        xhr.setRequestHeader("Content-type", "application/json");
+        xhr.withCredentials = true;
+        //  }
+
+        xhr.onload = function(e, f, g) {
+          var text = xhr.responseText;
+          if (OPrime.debugMode) {
+            OPrime.debug('Response from CORS request to ' + options.url + ': ' + text);
+          }
+          if (typeof options.success === "function") {
+            if (text) {
+              options.success(JSON.parse(text));
+            } else {
+              OPrime.bug("There was no content in the server's response text. Please report this.");
+              options.error(e, f, g);
+            }
+          }
+          OPrime.debugMode = false;
+        };
+
+        xhr.onerror = function(e, f, g) {
+          if (OPrime.debugMode) {
+            OPrime.debug(e, f, g);
+          }
+          OPrime.bug('There was an error making the CORS request to ' + options.url + " from " + window.location.href + " the app will not function normally. Please report this.");
+          if (typeof options.error === "function") {
+            options.error(e, f, g);
+          }
+        };
+        if (options.method === "POST") {
+          xhr.send(JSON.stringify(options.data));
+        } else {
+          xhr.send();
+        }
+
+      }
+    };
+    this.currentCorpusName = "";
+    this.downloadPrecedenceRules = function(pouchname, glosserURL, callback) {
+      if (!glosserURL || glosserURL === "default") {
+        if (!window.app) {
+          throw "Glosser cant be guessed, there is no app so the URL must be defined.";
+        }
+        var couchConnection = window.app.get("corpus").get("couchConnection");
+        var couchurl = OPrime.getCouchUrl(couchConnection);
+        glosserURL = couchurl + "/_design/pages/_view/precedence_rules?group=true";
+      }
+      var self = this;
+      OPrime.makeCORSRequest({
+        type: 'GET',
+        url: glosserURL,
+        success: function(rules) {
+          // Dont need to store the actual rules, they are too big
+          // try {
+          //   localStorage.setItem(pouchname + "precendenceRules", JSON.stringify(rules.rows));
+          // } catch (e) {
+          //   //remove other corpora's rules to make space for the most recent...
+          //   for (var x in localStorage) {
+          //     if(!localStorage.hasOwnProperty(x)){
+          //       continue;
+          //     }
+          //     if (x.indexOf("precendenceRules") > -1) {
+          //       localStorage.removeItem(x);
+          //     }
+          //   }
+          //   localStorage.setItem(pouchname + "precendenceRules", JSON.stringify(rules.rows));
+          // }
+
+          // Reduce the rules such that rules which are found in multiple source
+          // words are only used/included once.
+          var reducedRules = _.chain(rules.rows).groupBy(function(rule) {
+            if (rule.key.distance === 1) {
+              // upgrade to fancier context sensitive rules
+              if (rule.key.previous && rule.key.previous.morphemes) {
+                rule.key.x = rule.key.previous.morphemes;
+              }
+              if (rule.key.subsequent && rule.key.subsequent.morphemes) {
+                rule.key.y = rule.key.subsequent.morphemes;
+              }
+            }
+            return rule.key.x + "-" + rule.key.y;
+          }).value();
+
+          // Save the reduced precedence rules in localStorage
+          try {
+            localStorage.setItem(pouchname + "reducedRules", JSON.stringify(reducedRules));
+          } catch (error) {
+            //remove other corpora's rules to make space for the most recent...
+            for (var x in localStorage) {
+              if (x.indexOf("reducedRules") > -1) {
+                localStorage.removeItem(x);
+              }
+            }
+            try {
+              localStorage.setItem(pouchname + "reducedRules", JSON.stringify(reducedRules));
+            } catch (error2) {
+              console.warn('Your lexicon is huge!', error2);
+            }
+          }
+
+          self.reducedRules = reducedRules;
+
+          self.currentCorpusName = pouchname;
+          if (typeof callback === "function") {
+            callback(rules.rows);
+          }
+        },
+        error: function(e) {
+          console.log("error getting precedence rules:", e);
+        },
+        dataType: ""
+      });
+    };
+
+    /**
+     * Takes in an utterance line and, based on our current set of precendence
+     * rules, guesses what the morpheme line would be. The algorithm is
+     * very conservative.
+     *
+     * @param {String} unparsedUtterance The raw utterance line.
+     *
+     * @return {String} The guessed morphemes line.
+     */
+    this.morphemefinder = function(unparsedUtterance, pouchname, justCopyDontGuessIGT) {
+      if (!unparsedUtterance) {
+        return "";
+      }
+
+      if (justCopyDontGuessIGT) {
+        return unparsedUtterance;
+      }
+
+      if (!pouchname) {
+        if (!window.app || !window.app.get("corpus")) {
+          throw "Glosser can't be guessed, there is no app so the URL must be defined.";
+        }
+        pouchname = window.app.get("corpus").get("couchConnection").pouchname;
+      }
+
+      var potentialParse = '';
+      // Get the precedence rules from localStorage
+      var rules = this.reducedRules || localStorage.getItem(pouchname + "reducedRules");
+
+      var parsedWords = [];
+      if (rules) {
+        // Parse the rules from JSON into an object
+        rules = JSON.parse(rules);
+
+        // Divide the utterance line into words
+        var unparsedWords = unparsedUtterance.trim().split(/ +/);
+
+        for (var word in unparsedWords) {
+          // Add the start/end-of-word character to the word
+          unparsedWords[word] = "@" + unparsedWords[word] + "@";
+
+          // Find the rules which match in local precedence
+          var matchedRules = [];
+          for (var r in rules) {
+            if (unparsedWords[word].indexOf(r.replace(/-/, "")) >= 0) {
+              matchedRules.push({
+                r: rules[r]
+              });
+            }
+          }
+
+          // Attempt to find the longest template which the matching rules can
+          // generate from start to end
+          var prefixtemplate = [];
+          prefixtemplate.push("@");
+          for (var i = 0; i < 10; i++) {
+            if (prefixtemplate[i] === undefined) {
+              break;
+            }
+            for (var j in matchedRules) {
+              if (prefixtemplate.length > 2 && prefixtemplate[prefixtemplate.length - 1] === "@") {
+                continue; //we found the end already
+              }
+              if (prefixtemplate[i] === matchedRules[j].r[0].key.x) {
+                if (prefixtemplate[i + 1]) { // ambiguity (two potential following
+                  // morphemes)
+                  prefixtemplate.pop();
+                  break;
+                } else {
+                  prefixtemplate[i + 1] = matchedRules[j].r[0].key.y;
+                }
+              }
+            }
+          }
+          // If prefix template matches the whole word (ie we have seen it before, return the prefix template exactly)
+          if (prefixtemplate.length > 2 && prefixtemplate[0] === "@" && prefixtemplate[prefixtemplate.length - 1] === "@") {
+            prefixtemplate.pop(); //remove final @
+            prefixtemplate.shift(); //remove intitial @
+            parsedWords.push(prefixtemplate.join("-"));
+          } else {
+            // If the prefix template hit ambiguity in the middle, try from the suffix
+            // in until it hits ambiguity
+            var suffixtemplate = [];
+            if (prefixtemplate[prefixtemplate.length - 1] !== "@" || prefixtemplate.length === 1) {
+              // Suffix:
+              suffixtemplate.push("@");
+              for (var ii = 0; ii < 10; ii++) {
+                if (suffixtemplate[ii] === undefined) {
+                  break;
+                }
+                for (var jj in matchedRules) {
+                  if (suffixtemplate[ii] === matchedRules[jj].r[0].key.y) {
+                    if (suffixtemplate[ii + 1]) { // ambiguity (two potential
+                      // following morphemes)
+                      suffixtemplate.pop();
+                      break;
+                    } else {
+                      suffixtemplate[ii + 1] = matchedRules[jj].r[0].key.x;
+                    }
+                  }
+                }
+              }
+            }
+
+            // Combine prefix and suffix templates into one regular expression which
+            // can be tested against the word to find a potential parse.
+            // Regular expressions will look something like
+            //    (@)(.*)(hall)(.*)(o)(.*)(wa)(.*)(n)(.*)(@)
+            var template = [];
+            template = prefixtemplate.concat(suffixtemplate.reverse());
+            for (var slot in template) {
+              template[slot] = "(" + template[slot] + ")";
+            }
+            var regex = new RegExp(template.join("(.*)"), "");
+
+            // Use the regular expression to find a guessed morphemes line
+            potentialParse = unparsedWords[word]
+              .replace(regex, "$1-$2-$3-$4-$5-$6-$7-$8-$9") // Use backreferences to parse into morphemes
+            .replace(/\$[0-9]/g, "") // Remove any backreferences that weren't used
+            .replace(/@/g, "") // Remove the start/end-of-line symbol
+            .replace(/--+/g, "-") // Ensure that there is only ever one "-" in a row
+            .replace(/^-/, "") // Remove "-" at the start of the word
+            .replace(/-$/, ""); // Remove "-" at the end of the word
+            if (OPrime.debugMode) {
+              OPrime.debug("Potential parse of " + unparsedWords[word].replace(/@/g, "") + " is " + potentialParse);
+            }
+
+            parsedWords.push(potentialParse);
+          }
+
+        }
+      }
+
+      return parsedWords.join(" ");
+    };
+
+    this.contextSensitiveGlossFinder = function(igt, pouchname, justCopyDontGuessIGT) {
+      var morphemesLine = igt.morphemes;
+      if (!morphemesLine) {
+        return "";
+      }
+
+      if (justCopyDontGuessIGT || !this.lexicon) {
+        var justQuestionMarks = morphemesLine.trim().replace(/[^ =-]+/g, "?");
+        igt.gloss = justQuestionMarks;
+      } else {
+        igt = this.lexicon.guessContextSensitiveGlosses(igt);
+      }
+
+      return igt;
+    };
+
+    this.simplisticGlossFinder = function(morphemesLine, pouchname, justCopyDontGuessIGT) {
+      if (!morphemesLine) {
+        return "";
+      }
+
+      if (justCopyDontGuessIGT) {
+        var justQuestionMarks = morphemesLine.trim().replace(/[^ -]+/g, "?");
+        return justQuestionMarks;
+      }
+
+      if (!pouchname) {
+        if (!window.app || !window.app.get("corpus")) {
+          throw "Glosser can't be guessed, there is no app so the URL must be defined.";
+        }
+        pouchname = window.app.get("corpus").get("couchConnection").pouchname;
+      }
+
+      var lexiconNodes = localStorage.getItem(pouchname + "lexiconResults");
+      if (!lexiconNodes) {
+        return "";
+      }
+
+      lexiconNodes = JSON.parse(lexiconNodes);
+
+      var glossGroups = [];
+      var morphemeGroup = morphemesLine.split(/ +/);
+      for (var group in morphemeGroup) {
+        var morphemes = morphemeGroup[group].split("-");
+        var glosses = [];
+        for (var m in morphemes) {
+
+          var matchingNodes = [];
+          var node = lexiconNodes[morphemes[m]];
+          if (node) {
+            matchingNodes.push(node);
+          }
+          node = lexiconNodes[morphemes[m].toLowerCase()];
+          if (node) {
+            matchingNodes.push(node);
+          }
+          var gloss = "?"; // If there's no matching gloss, use question marks
+          if (matchingNodes.length > 0) {
+            // Take the first gloss for this morpheme
+            console.log("Glosses which match: ", matchingNodes);
+            try {
+              gloss = matchingNodes[0][0].gloss;
+            } catch (e) {
+              OPrime.debug(matchingNodes);
+            }
+          }
+          glosses.push(gloss);
+
+        }
+
+        glossGroups.push(glosses.join("-"));
+      }
+
+      // Replace the gloss line with the guessed glosses
+      return glossGroups.join(" ");
+    };
+
+    this.guessUtteranceFromMorphemes = function(igt, justCopyDontGuessIGT) {
+      if (!igt.utterance && igt.morphemes) {
+        igt.utterance = igt.morphemes.replace(/[-.]/g, "");
+      }
+      return igt;
+    };
+
+    this.guessMorphemesFromUtterance = function(igt, justCopyDontGuessIGT) {
+      if (igt.morphemes) {
+        return igt;
+      }
+      igt.morphemes = this.morphemefinder(igt.utterance, igt.pouchname, justCopyDontGuessIGT);
+      if (!igt.gloss) {
+        igt = this.contextSensitiveGlossFinder(igt, igt.pouchname, justCopyDontGuessIGT);
+      }
+      return igt;
+    };
+
+    this.guessGlossFromMorphemes = function(igt, justCopyDontGuessIGT) {
+      if (igt.gloss) {
+        return igt;
+      }
+      if (!igt.morphemes) {
+        igt.morphemes = igt.utterance;
+      }
+      igt = this.contextSensitiveGlossFinder(igt, igt.pouchname, justCopyDontGuessIGT);
+      return igt;
+    };
+
+    /**
+     * Takes as a parameters an array of rules which came from CouchDB precedence rule query.
+     * Example Rule: {"key":{"x":"@","relation":"preceeds","y":"aqtu","context":"aqtu-nay-wa-n"},"value":2}
+     */
+    this.generateForceDirectedRulesJsonForD3 = function(rules, pouchname) {
+      if (!pouchname) {
+        pouchname = this.currentCorpusName;
+      }
+      if (!rules) {
+        rules = this.reducedRules;
+        if (!rules) {
+          localStorage.getItem(pouchname + "precendenceRules");
+          if (rules) {
+            rules = JSON.parse(rules);
+          }
+        }
+      }
+      if (!rules) {
+        return;
+      }
+      /*
+       * Cycle through the precedence rules, convert them into graph edges with the morpheme index in the morpheme array as the source/target values
+       */
+      var morphemeLinks = [];
+      var morphemes = [];
+      for (var i in rules) {
+        /* make the @ more like what a linguist recognizes for word boundaries */
+        if (rules[i].key.x === "@") {
+          rules[i].key.x = "#_";
+        }
+        if (rules[i].key.y === "@") {
+          rules[i].key.y = "_#";
+        }
+        var xpos = morphemes.indexOf(rules[i].key.x);
+        if (xpos < 0) {
+          morphemes.push(rules[i].key.x);
+          xpos = morphemes.length - 1;
+        }
+        var ypos = morphemes.indexOf(rules[i].key.y);
+        if (ypos < 0) {
+          morphemes.push(rules[i].key.y);
+          ypos = morphemes.length - 1;
+        }
+        //To avoid loops?
+        if (rules[i].key.y.indexOf("@") === -1) {
+          morphemeLinks.push({
+            source: xpos,
+            target: ypos,
+            value: 1 //TODO use the context counting to get a weight measure
+          });
+        }
+      }
+
+      /*
+       * Build the morphemes into nodes and color them by their morpheme length, could be a good measure of outliers
+       */
+      var morphemenodes = [];
+      for (var m in morphemes) {
+        morphemenodes.push({
+          name: morphemes[m],
+          length: morphemes[m].length
+        });
+      }
+
+      /*
+       * Create the JSON required by D3
+       */
+      var rulesGraph = {};
+      rulesGraph.links = morphemeLinks;
+      rulesGraph.nodes = morphemenodes;
+      this.rulesGraph = rulesGraph;
+
+      return rulesGraph;
+    };
+
+    this.saveAndInterConnectInApp = function(callback) {
+
+      if (typeof callback === "function") {
+        callback();
+      }
+    };
+    /*
+     * Some sample D3 from the force-html.html example
+     *
+     */
+    //this.rulesGraph = this.rulesGraph || {};
+    this.visualizeMorphemesAsForceDirectedGraph = function(rulesGraph, divElement, pouchname) {
+
+      if (pouchname) {
+        this.currentCorpusName = pouchname;
+      } else {
+        throw ("Must provide corpus name to be able to visualize morphemes");
+      }
+      if (!rulesGraph) {
+        rulesGraph = this.rulesGraph;
+        if (rulesGraph) {
+          if (rulesGraph.links.length === 0) {
+            rulesGraph = this.generateForceDirectedRulesJsonForD3();
+          }
+        } else {
+          rulesGraph = this.generateForceDirectedRulesJsonForD3();
+        }
+      }
+      if (!rulesGraph) {
+        return;
+      }
+      if (this.rulesGraph.links.length === 0) {
+        return;
+      }
+      var json = rulesGraph;
+      var width = 800,
+        height = 300;
+      /*
+    Short morphemes will be blue, long will be red
+    */
+      var color = d3.scale.linear()
+        .range(['darkblue', 'darkred']) // or use hex values
+        .domain([1, 8]);
+      var lineColor = d3.scale.linear()
+        .range(['#FFFFF', '#FFFF00']) // or use hex values
+        .domain([1, 8]);
+
+      var x = d3.scale.linear()
+        .range([0, width]);
+
+      var y = d3.scale.linear()
+        .range([0, height - 40]);
+
+      var force = d3.layout.force()
+        .charge(-120)
+        // .linkStrength(0.2)
+        .linkDistance(30)
+        .size([width, height]);
+
+      var svg = d3.select(divElement).append("svg")
+        .attr("width", width)
+        .attr('title', "Morphology Visualization for " + pouchname)
+        .attr("height", height);
+
+      var titletext = "Click to search morphemes in your corpus";
+      if (rulesGraph.nodes.length < 3) {
+        titletext = "Your morpheme visualizer will appear here after you have synced.";
+      }
+      //A label for the current year.
+      var title = svg.append("text")
+        .attr("class", "vis-title")
+        .attr("dy", "1em")
+        .attr("dx", "1em")
+        .style("fill", "#cccccc")
+        //    .attr("transform", "translate(" + x(1) + "," + y(1) + ")scale(-1,-1)")
+        .text(titletext);
+
+      var tooltip = null;
+
+      //d3.json("./libs/rules.json", function(json) {
+      force
+        .nodes(json.nodes)
+        .links(json.links)
+        .start();
+
+      var link = svg.selectAll("line.link")
+        .data(json.links)
+        .enter().append("line")
+        .attr("class", "link")
+        .style("stroke", function(d) {
+          return lineColor(d.value);
+        })
+        .style("stroke-width", function(d) {
+          return d.value;
+        });
+
+      var node = svg.selectAll("circle.node")
+        .data(json.nodes)
+        .enter().append("circle")
+        .attr("class", "node")
+        .attr("r", 5)
+        .attr("data-details", function(d) {
+          return d;
+        })
+        .style("fill", function(d) {
+          if (d.igt.morphemes === "#_") {
+            return '#00000';
+          }
+          if (d.igt.morphemes === "_#") {
+            return '#ffffff';
+          }
+          return color(d.length);
+        })
+        .on("mouseover", function(d) {
+          tooltip = d3.select("body")
+            .append("div")
+            .style("position", "absolute")
+            .style("z-index", "10")
+            .style("visibility", "visible")
+            .style("color", "#fff")
+            .text(d.igt.morphemes);
+        })
+        .on("mouseout", function() {
+          tooltip.style("visibility", "hidden");
+        })
+        .on("click", function(d) {
+          /* show the morpheme as a search result so the user can use the viz to explore the corpus*/
+          if (window.app && window.app.router) {
+            // window.app.router.showEmbeddedSearch(pouchname, "morphemes:"+d.igt.morphemes);
+            var url = "corpus/" + pouchname + "/search/" + "morphemes:" + d.igt.morphemes;
+            // window.location.replace(url);
+            window.app.router.navigate(url, {
+              trigger: true
+            });
+
+          }
+        })
+        .call(force.drag);
+
+      node.append("title")
+        .text(function(d) {
+          return d.igt.morphemes;
+        });
+
+      force.on("tick", function() {
+        link.attr("x1", function(d) {
+          return d.source.x;
+        })
+          .attr("y1", function(d) {
+            return d.source.y;
+          })
+          .attr("x2", function(d) {
+            return d.target.x;
+          })
+          .attr("y2", function(d) {
+            return d.target.y;
+          });
+
+        node.attr("cx", function(d) {
+          return d.x;
+        })
+          .attr("cy", function(d) {
+            return d.y;
+          });
+      });
+      //});
+    };
+
+    /**
+     * http://bl.ocks.org/mbostock/1153292
+     * http://alignedleft.com/tutorials/d3/binding-data
+     *
+     * @param  {[type]} rulesGraph [description]
+     * @param  {[type]} divElement [description]
+     * @param  {[type]} pouchname  [description]
+     * @return {[type]}            [description]
+     */
+    this.visualizePrecedenceRelationsAsForceDirectedGraph = function(lexicon, divElement, dontConnectOnWordBoundaries, confidenceCutOff) {
+
+      var precedenceGraph = {
+        links: [],
+        nodes: {}
+      };
+      if (!this.localDocument) {
+        console.warn(" Glosser Visualization requested but the DOM was not provided to the glosser ");
+        return;
+      }
+      var localDocument = this.localDocument;
+
+      lexicon.precedenceGraph = lexicon.precedenceRelations.filter(function(relation) {
+        if (!relation.key.previous || !relation.key.subsequent) {
+          // console.log("skipping ", relation.key);
+          return;
+        }
+        if (!relation.key.previous.morphemes || !relation.key.subsequent.morphemes) {
+          // console.log("skipping ", relation.key);
+          return;
+        }
+        /* skip word boundaries if requested */
+        if (relation.key.previous.morphemes === "@" || relation.key.previous.morphemes === "_#" || relation.key.previous.morphemes === "#_" || relation.key.subsequent.morphemes === "@" || relation.key.subsequent.morphemes === "_#" || relation.key.subsequent.morphemes === "#_") {
+          if (dontConnectOnWordBoundaries) {
+            return;
+          }
+        }
+        /* make the @ more like what a linguist recognizes for  word boundaries */
+        if (relation.key.previous.morphemes === "@") {
+          relation.key.previous.morphemes = "#_";
+        }
+        if (relation.key.subsequent.morphemes === "@") {
+          relation.key.subsequent.morphemes = "_#";
+        }
+
+        // only consider immediate precedence
+        if (relation.key.distance > 1) {
+          return;
+        }
+        // only consider -> relations
+        if (relation.key.relation !== "precedes") {
+          return;
+        }
+        // only confident morphemes
+        confidenceCutOff = confidenceCutOff || 1;
+        if (relation.key.previous.confidence < confidenceCutOff || relation.key.subsequent.confidence < confidenceCutOff) {
+          return;
+        }
+        relation.key.source = relation.key.previous;
+        relation.key.target = relation.key.subsequent;
+        precedenceGraph.links.push(relation.key);
+      });
+      lexicon.precedenceGraph = precedenceGraph;
+
+      if (!lexicon.precedenceGraph) {
+        return;
+      }
+      if (lexicon.precedenceGraph.links.length === 0) {
+        return;
+      }
+
+      var width = divElement.clientWidth,
+        height = 600;
+
+      // Get the complete node for the links.
+      lexicon.precedenceGraph.links.map(function(link) {
+        if(!link || !link.source || !link.source.morphemes || !link.target || !link.target.morphemes ){
+          return;
+        }
+        if (!lexicon.precedenceGraph.nodes[link.source.morphemes]) {
+          lexicon.precedenceGraph.nodes[link.source.morphemes] = {
+            igt: link.source
+          };
+        }
+        link.source = lexicon.precedenceGraph.nodes[link.source.morphemes];
+
+        if (!lexicon.precedenceGraph.nodes[link.target.morphemes]) {
+          lexicon.precedenceGraph.nodes[link.target.morphemes] = {
+            igt: link.target
+          };
+        }
+        link.target = lexicon.precedenceGraph.nodes[link.target.morphemes];
+      });
+      window.mylexicon = lexicon;
+      var tooltip = d3.select("body")
+        .append("div")
+        .style("position", "absolute")
+        .style("z-index", "10")
+        .style("visibility", "hidden")
+        .html("");
+
+      var linkArc = function(d) {
+        var dx = d.source.x - d.target.x,
+          dy = d.source.y - d.target.y,
+          dr = Math.sqrt(dx * dx + dy * dy); //uncomment to curve the lines
+        // dr = 0;
+        return "M" + d.source.x + "," + d.source.y + "A" + dr + "," + dr + " 0 0,1 " + d.target.x + "," + d.target.y;
+      };
+
+      var transform = function(d) {
+        if (d.igt.morphemes === "_#") {
+          d.x = width - 20;
+          d.y = height / 2;
+        }
+        if (d.igt.morphemes === "#_") {
+          d.x = 20;
+          d.y = height / 2;
+        }
+        return "translate(" + d.x + "," + d.y + ")";
+      };
+
+      /*
+      Short morphemes will be blue, long will be red
+      */
+      var color = d3.scale.linear()
+        .range(['darkblue', 'darkred']) // or use hex values
+        .domain([1, 8]);
+
+      var lineColor = d3.scale.linear()
+        .range(['#FFFFF', '#FFFF00']) // or use hex values
+        .domain([1, 8]);
+
+      // var force = d3.layout.force()
+      //   .charge(-120)
+      //   .linkStrength(0.2)
+      //   .linkDistance(30)
+      //   .size([width, height]);
+
+      var force = d3.layout.force()
+        .nodes(d3.values(lexicon.precedenceGraph.nodes))
+        .links(lexicon.precedenceGraph.links)
+        .size([width, height])
+        .linkStrength(0.5)
+        .linkDistance(60)
+        .charge(-400);
+
+      var svg = d3.select(divElement).append("svg")
+        .attr("width", width)
+        .attr("height", height);
+
+      // Per-type markers, as they don't inherit styles.
+      svg.append("defs").selectAll("marker")
+        .data(["precedes"])
+      // .data(["suit", "licensing", "resolved"])
+      .enter()
+        .append("marker")
+        .attr("id", function(d) {
+          return d;
+        })
+        .style("opacity", function(d) {
+          // return color(d.igt.morphemes.length);
+          return 0.5;
+        })
+        .attr("viewBox", "0 -5 10 10")
+        .attr("refX", 15)
+        .attr("refY", -1.5)
+        .attr("markerWidth", 6)
+        .attr("markerHeight", 6)
+        .attr("orient", "auto")
+        .append("path")
+        .attr("d", "M0,-5L10,0L0,5");
+
+      var path = svg.append("g").selectAll("path")
+        .data(force.links())
+        .enter().append("path")
+        .attr("class", function(d) {
+          return "link " + d.relation + " distance" + d.distance;
+        })
+        .attr("marker-end", function(d) {
+          return "url(#" + d.relation + ")";
+        });
+
+      var circle = svg.append("g").selectAll("circle")
+        .data(force.nodes())
+        .enter().append("circle")
+        .attr("class", "node")
+        .attr("r", 5)
+        .style("fill", function(d) {
+          if (d.igt.morphemes === "#_") {
+            return '#00000';
+          }
+          if (d.igt.morphemes === "_#") {
+            return '#ffffff';
+          }
+          return color(d.igt.morphemes.length);
+          // return color(d.igt.confidence * 10);
+        })
+        .style("opacity", function(d) {
+          // return color(d.igt.morphemes.length);
+          return d.igt.confidence ? d.igt.confidence / 2 : 1;
+        })
+        .on("mouseover", function(object) {
+          var findNode = localDocument.getElementById(object.igt.morphemes);
+          if (findNode) {
+            findNode = findNode.innerHTML + "<p>" + findNode.getAttribute("title") + "<p>";
+          } else {
+            findNode = "Morpheme: " + object.igt.morphemes + "<br/> Gloss: " + object.igt.gloss + "<br/> Confidence: " + object.igt.confidence;
+          }
+          return tooltip
+            .style("visibility", "visible")
+            .html("<div class='node_details_tooltip lexicon'>" + findNode + "</div>");
+        })
+        .on("mousemove", function(object) {
+          /*global  event */
+          return tooltip.style("top", (event.pageY - 10) + "px")
+            .style("left", (event.pageX + 10) + "px");
+        })
+        .on("mouseout", function(object) {
+          return tooltip
+            .style("visibility", "hidden");
+        })
+        .on("click", function(d) {
+          /* show the morpheme as a search result so the user can use the viz to explore the corpus*/
+          if (window.app && window.app.router) {
+            // window.app.router.showEmbeddedSearch(pouchname, "morphemes:"+d.igt.morphemes);
+            var url = "corpus/" + lexicon.pouchname + "/search/" + "morphemes:" + d.igt.morphemes;
+            // window.location.replace(url);
+            window.app.router.navigate(url, {
+              trigger: true
+            });
+
+          }
+        })
+        .call(force.drag);
+
+      var text = svg.append("g").selectAll("text")
+        .data(force.nodes())
+        .enter().append("text")
+        .attr("x", 8)
+        .attr("y", ".31em")
+        .style("opacity", function(d) {
+          // return color(d.igt.morphemes.length);
+          return d.igt.confidence ? d.igt.confidence / 2 : 1;
+        })
+        .style("color", function(d) {
+          if (d.igt.morphemes === "#_") {
+            return '#00000';
+          }
+          if (d.igt.morphemes === "_#") {
+            return '#ffffff';
+          }
+          return color(d.igt.morphemes.length);
+          // return color(d.igt.confidence * 10);
+        })
+        .text(function(d) {
+          return d.igt.morphemes;
+        });
+
+
+      // Use elliptical arc path segments to doubly-encode directionality.
+      var tick = function() {
+        path.attr("d", linkArc);
+        circle.attr("transform", transform);
+        text.attr("transform", transform);
+      };
+
+      force
+        .on("tick", tick)
+        .start();
+
+
+    };
+    return this;
+  };
+  exports.Glosser = Glosser;
+  global.Glosser = Glosser;
+
+}(typeof exports === 'object' && exports || this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./Lexicon":5,"d3":25,"underscore":105}],5:[function(require,module,exports){
+(function (global){
+var ObservableDOM = require("frb/dom"); // add support for content editable
+var Bindings = require("frb/bindings");
+var SortedSet = require("collections/sorted-set");
+var UniqueSet = require("collections/set");
+var CORS = require("../../FieldDB/api/CORS").CORS;
+var Q = require("q");
+(function(exports) {
+
+  /* globals FieldDB */
+  var escapeRegexCharacters = function(regex) {
+    return regex.replace(/([()[{*+.$^\\|?])/g, '\\$1');
+  };
+
+  var LexiconNode = function(options) {
+    for (var property in options) {
+      if (options.hasOwnProperty(property)) {
+        this[property] = options[property];
+      }
+    }
+    this.fossil = JSON.parse(JSON.stringify(options.igt));
+    Object.call(this);
+  };
+
+  LexiconNode.prototype = Object.create(Object.prototype, {
+    constructor: {
+      value: LexiconNode
+    },
+    equals: {
+      value: function(b) {
+        var a = this;
+        var equal = false;
+        var fieldIndex,
+          field,
+          tmpArray;
+
+        for (fieldIndex in this.expandedIGTFields) {
+          field = this.expandedIGTFields[fieldIndex];
+          if (a.igt.hasOwnProperty(field)) {
+            if (a.igt[field] === b.igt[field]) {
+              equal = true;
+            }
+          }
+        }
+        // If the nodes are "equal" then make sure they have the same combineFieldsIfEqual
+        if (equal) {
+          for (fieldIndex in this.combineFieldsIfEqual) {
+            field = this.combineFieldsIfEqual[fieldIndex];
+            if (a.hasOwnProperty(field)) {
+              tmpArray = [];
+              a[field] = a[field].concat(b[field]);
+              /*jshint loopfunc: true */
+              a[field].map(function(item) {
+                if (tmpArray.indexOf(item) === -1) {
+                  tmpArray.push(item);
+                }
+              });
+              a[field] = tmpArray;
+              b[field] = tmpArray;
+            }
+          }
+          if (a.confidence && b.confidence) {
+            a.confidence = (parseFloat(a.confidence, 10) + parseFloat(b.confidence, 10)) / 2;
+            b.confidence = a.confidence;
+          }
+          if (a.allomorphs || b.allomorphs) {
+            var allomorphs = a.allomorphs ? a.allomorphs : "";
+            allomorphs = allomorphs + allomorphs ? ", " : "";
+            allomorphs = allomorphs + b.allomorphs ? b.allomorphs : "";
+            a.allomorphs = allomorphs;
+            b.allomorphs = allomorphs;
+          }
+        }
+        return equal;
+      }
+    },
+    expandedIGTFields: {
+      value: ["morphemes", "gloss", "allomorphy", "phonetic", "orthography"]
+    },
+    combineFieldsIfEqual: {
+      value: ["datumids", "utteranceContext"]
+    },
+    sortBy: {
+      value: "morphemes",
+      writable: true
+    },
+    compare: {
+      value: function(b) {
+        var a = this;
+        var result = 0;
+        if (!b || !b.igt || !b.igt[this.sortBy]) {
+          return -1;
+        }
+        if (!a || !a.igt || !a.igt[this.sortBy]) {
+          return 1;
+        }
+        if ((typeof(a.igt[this.sortBy]) === 'number') && (typeof(b.igt[this.sortBy]) === 'number')) {
+          result = a.igt[this.sortBy] - b.igt[this.sortBy];
+        } else if ((typeof(a.igt[this.sortBy]) === 'string') && (typeof(b.igt[this.sortBy]) === 'string')) {
+          if (a.igt[this.sortBy] < b.igt[this.sortBy]) {
+            result = -1;
+          } else if (a.igt[this.sortBy] > b.igt[this.sortBy]) {
+            result = 1;
+          } else {
+            result = 0;
+          }
+        } else if (typeof(a.igt[this.sortBy]) === 'string') {
+          result = 1;
+        } else {
+          result = -1;
+        }
+        return result;
+      }
+    },
+    clean: {
+      value: function() {
+        console.log("Preparing datum with this lexical entry to be cleaned...");
+        var deffered = Q.defer();
+        this.cleanedData = [];
+        var promises = [];
+        var self = this;
+        this.proposedChanges = [];
+
+        var successFunction = function(doc) {
+          console.log(doc);
+          doc.datumFields.map(function(datumField) {
+            if (self.fossil[datumField.label] !== self.igt[datumField.label] && (new RegExp(escapeRegexCharacters(self.fossil[datumField.label]), "i")).test(datumField.mask)) {
+              var change = {
+                before: datumField.mask + ""
+              };
+              // TODO this makes things lower case... because part of the map reduce seems to be doing that...
+              datumField.mask = datumField.mask.replace(new RegExp(escapeRegexCharacters(self.fossil[datumField.label]), "ig"), self.igt[datumField.label]);
+              datumField.value = datumField.mask;
+              change.after = datumField.mask;
+              self.proposedChanges.push(change);
+              return datumField;
+            }
+          });
+          self.cleanedData.push(doc);
+        };
+        var failFunction = function(reason) {
+          console.log(reason);
+          if (FieldDB && FieldDB.FieldDBObject && typeof FieldDB.FieldDBObject.bug === "function"){
+            FieldDB.FieldDBObject.bug("There was a problem saving your changes. " + reason.reason); 
+          }
+        };
+
+        for (var idIndex = 0; idIndex < this.datumids.length; idIndex++) {
+          console.log(this.datumids.length[idIndex]);
+          promises[idIndex] = CORS.makeCORSRequest({
+            method: 'GET',
+            dataType: 'json',
+            url: this.url + "/" + this.datumids[idIndex]
+          });
+          promises[idIndex].then(successFunction).fail(failFunction);
+        }
+        Q.allSettled(promises).then(function(results) {
+          deffered.resolve(self.proposedChanges);
+        });
+        return deffered.promise;
+      }
+    },
+    save: {
+      value: function() {
+        var deffered = Q.defer(),
+          self = this,
+          promises = [];
+
+        console.log("Saving cleaned datum...");
+        while (this.cleanedData.length > 0) {
+          var cleanedDatum = this.cleanedData.pop();
+          promises.push(CORS.makeCORSRequest({
+            method: 'PUT',
+            dataType: 'json',
+            data: cleanedDatum,
+            url: this.url + "/" + cleanedDatum._id
+          }));
+        }
+        Q.allSettled(promises).then(function(results) {
+          deffered.resolve(results);
+          self.unsaved = true;
+        });
+        return deffered.promise;
+      }
+    },
+    unsaved: {
+      configurable: true,
+      get: function() {
+        if (this._unsaved) {
+          return this._unsaved;
+        }
+        if (this.fossil && !this.equals({
+          igt: this.fossil
+        })) {
+          this._unsaved = true;
+        }
+        return this._unsaved;
+      },
+      set: function(value) {
+        this._unsaved = value;
+      }
+    }
+  });
+
+
+  var Lexicon = function(values, equals, compare, getDefault) {
+    console.log("\tConstructing Lexicon... ");
+    // SortedSet.apply(this, [values, equals, compare, getDefault]);
+    SortedSet.apply(this, Array.prototype.slice.call(arguments, 1));
+    // if (!compare) {
+    //   this.contentCompare = this.__proto__.igtCompare;
+    // }
+    // if (!equals) {
+    //   this.contentEquals = this.__proto__.igtEqual;
+    // }
+  };
+
+  Lexicon.prototype = Object.create(SortedSet.prototype, {
+    constructor: {
+      value: Lexicon
+    },
+    sortBy: {
+      value: "morphemes"
+    },
+    bindToView: {
+      value: function() {
+        var element,
+          binding,
+          bindings = [],
+          listElement,
+          entryvalue,
+          entrykey,
+          iterate,
+          entryIndex,
+          listItemView,
+          fieldLabelElement,
+          fieldDTElement,
+          fieldDDElement,
+          fieldElement,
+          fieldList,
+          headword,
+          saveButton,
+          contexts,
+          field,
+          classList;
+
+        var self = this;
+        element = this.element;
+        if (!element) {
+          return;
+        }
+        if (!self.localDOM) {
+          return;
+        }
+        listElement = self.localDOM.createElement("ul");
+        element.appendChild(listElement);
+
+        this.forEach(function(entry) {
+          var discussion,
+            field;
+
+          if (entry.igt && entry.igt.morphemes === "@") {
+            return;
+          }
+
+          listItemView = self.localDOM.createElement("li");
+          listItemView.__data__ = entry;
+          listItemView.style.opacity = listItemView.__data__.igt.confidence;
+          if (listItemView.__data__.igt.morphemes) {
+            listItemView.id = listItemView.__data__.igt.morphemes;
+          }
+          // console.log("\tCreating Node view for " + listItemView.id);
+
+          headword = self.localDOM.createElement("span");
+          headword.contentEditable = 'true';
+          headword.classList.add("headword");
+          headword.setAttribute("title", "CLick to edit the headword of your lexical entry");
+          listItemView.__data__.igt.headword = listItemView.__data__.igt.headword || listItemView.__data__.igt.morphemes ? listItemView.__data__.igt.morphemes : listItemView.__data__.igt.gloss;
+
+          saveButton = self.localDOM.createElement("button");
+          saveButton.classList.add("btn");
+          saveButton.setAttribute("title", "Click here to save");
+          saveButton.innerHTML = "Save";
+
+          contexts = self.localDOM.createElement("span");
+          contexts.classList.add("utteranceContext");
+
+          discussion = self.localDOM.createElement("span");
+          discussion.contentEditable = 'true';
+          discussion.classList.add("discussion");
+          discussion.hidden = true;
+          listItemView.__data__.igt.discussion = listItemView.__data__.igt.discussion || "Lorem ipsum dolor sit amet, consectetur adipisicing elit, ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
+          listItemView.ondblclick = function(e) {
+            /* If the user double clicks a node, they can investigate its data in the console */
+            if (!e || !e.target || !e.target.__data__) {
+              return;
+            }
+            /* Create the json View if its not there, otherwise toggle its hidden */
+            if (!e.target.jsonView) {
+              e.target.jsonView = self.localDOM.createElement("textarea");
+              e.target.appendChild(e.target.jsonView);
+              e.target.jsonView.classList.add("lexiconJSON");
+              discussion.hidden = !discussion.hidden;
+            } else {
+              var result = e.target.__data__.clean().then(function(proposedChanges) {
+                if (proposedChanges.length > 0) {
+                  var changesAsStrings = [];
+                  proposedChanges.map(function(change) {
+                    changesAsStrings.push(change.before + " -> " + change.after);
+                  });
+                  var saveEditToAllData = window.confirm("Would you like to clean this lexical entry? (This will change all examples you see here to have this new information.)\n\n" + changesAsStrings.join("\n"));
+                  if (saveEditToAllData) {
+                    e.target.__data__.save().then(function(result) {
+                      console.log("Saving success...", result);
+                    }).fail(function(reason) {
+                      console.log("Saving failed...", reason);
+                    });
+                  }
+                }
+              });
+              discussion.hidden = !discussion.hidden;
+              e.target.jsonView.hidden = discussion.hidden;
+            }
+            /* If jsonView is becomming hidden, save its values to the data, otherwise, fill it with the current data */
+            if (e.target.jsonView.hidden) {
+              var newIgt;
+              try {
+                newIgt = JSON.parse(e.target.jsonView.innerHTML);
+                for (var field in newIgt) {
+                  if (newIgt.hasOwnProperty(field)) {
+                    // e.target.__data__.igt[field] = newIgt[field];
+                  }
+                }
+              } catch (except) {
+                console.warn("Invalid JSON " + e.target.jsonView.innerHTML, except);
+              }
+            } else {
+              e.target.jsonView.innerHTML = JSON.stringify(e.target.__data__.igt, null, 2);
+            }
+            window.currentlySelectedNode = e.target;
+            console.log(window.currentlySelectedNode.__data__);
+          };
+
+          fieldList = self.localDOM.createElement("dl");
+
+          var component = {
+            listItemView: listItemView,
+            saveButtonView: saveButton,
+            headwordView: headword,
+            contextsView: contexts,
+            discussionView: discussion,
+            fieldListView: fieldList,
+            fieldViews: {},
+            data: entryvalue
+          };
+
+          for (field in listItemView.__data__.igt) {
+            if (listItemView.__data__.igt.hasOwnProperty(field)) {
+              if (field === "discussion" || field === "headword") {
+                continue;
+              }
+              try {
+                headword.classList.add(field + ":" + listItemView.__data__.igt[field]);
+                discussion.classList.add(field + ":" + listItemView.__data__.igt[field]);
+
+                fieldDTElement = self.localDOM.createElement("dt");
+                fieldLabelElement = self.localDOM.createElement("span");
+                fieldLabelElement.innerHTML = field;
+                fieldLabelElement.classList.add("fieldlabel");
+                fieldLabelElement.classList.add(field);
+                fieldLabelElement.classList.add(listItemView.__data__.igt[field]);
+                fieldDTElement.appendChild(fieldLabelElement);
+                fieldList.appendChild(fieldDTElement);
+
+                fieldDDElement = self.localDOM.createElement("dd");
+                fieldElement = self.localDOM.createElement("span");
+                fieldElement.contentEditable = 'true';
+                fieldElement.classList.add("fieldvalue");
+                fieldElement.classList.add(field);
+                fieldElement.classList.add(listItemView.__data__.igt[field]);
+                component.fieldViews[field] = fieldElement;
+                fieldDDElement.appendChild(fieldElement);
+                fieldList.appendChild(fieldDDElement);
+
+                var viewPath = "fieldViews." + field + ".value";
+                var dataPath = "listItemView.__data__.igt." + field;
+                var bindSet = {};
+                bindSet[viewPath] = {
+                  "<-": dataPath
+                };
+                var bindTwoWay = {};
+                bindTwoWay[dataPath] = {
+                  "<->": viewPath
+                };
+                Bindings.defineBindings(component, bindSet);
+                Bindings.defineBindings(component, bindTwoWay);
+
+              } catch (e) {
+                console.warn(e);
+              }
+            }
+          }
+
+          Bindings.defineBindings(component, {
+            "headwordView.value": {
+              "<-": "listItemView.__data__.igt.headword"
+            },
+            "saveButtonView.innerHTML": {
+              "<-": "'Save '+listItemView.__data__.igt.headword"
+            },
+            "saveButtonView.classList.has('btn-danger')": {
+              "<-": "listItemView.__data__.unsaved"
+            },
+            "discussionView.value": {
+              "<-": "listItemView.__data__.igt.discussion"
+            },
+            "contextsView.innerHTML": {
+              // "<-": "' '+listItemView.__data__.utteranceContext.join(',')+listItemView.__data__.utteranceContext?listItemView.__data__.utteranceContext.length : '0'"
+              "<-": "listItemView.__data__.utteranceContext.join(' ; ')"
+            },
+            "listItemView.title": {
+              "<-": "'Example: '+listItemView.__data__.utteranceContext.join(' Example: ')"
+            },
+            "listItemView.hidden": {
+              "<-": "listItemView.__data__.igt.confidence < self.localDOM.getElementById('lexiconConfidenceThreshold').value / 10"
+            }
+          });
+
+          Bindings.defineBindings(component, {
+            "listItemView.__data__.igt.headword": {
+              "<->": "headwordView.value"
+            },
+            "listItemView.__data__.igt.discussion": {
+              "<->": "discussionView.value"
+            }
+          });
+
+          listItemView.appendChild(headword);
+          listItemView.appendChild(discussion);
+          listItemView.appendChild(fieldList);
+          listItemView.appendChild(contexts);
+          listItemView.appendChild(saveButton);
+          listElement.appendChild(listItemView);
+
+        });
+
+      }
+    },
+    toJSON: {
+      value: function() {
+        return JSON.stringify(this.toObject(), null, 2);
+      }
+    },
+
+    guessContextSensitiveGlosses: {
+      value: function(datum) {
+
+        if (!datum.morphemes) {
+          console.warn("There was no morphemes line to guess the gloss from...");
+          return datum;
+        }
+        var glossGroups = [];
+        var matchingNodes = [];
+        var morphemeToFind = "";
+        var morphemeGroup = datum.morphemes.split(/ +/);
+        var matchingfunction = function(node) {
+          if (node.igt.morphemes === morphemeToFind) {
+            console.log(node);
+            matchingNodes.push(node);
+          }
+        };
+        for (var group in morphemeGroup) {
+          var morphemes = morphemeGroup[group].split("-");
+          var glosses = [];
+          for (var m in morphemes) {
+            if (!morphemes.hasOwnProperty(m)) {
+              continue;
+            }
+            matchingNodes = [];
+            morphemeToFind = morphemes[m];
+            this.filter(matchingfunction);
+
+            var gloss = "?"; // If there's no matching gloss, use question marks
+            if (matchingNodes && matchingNodes.length > 0) {
+              // Take the first gloss for this morpheme
+              console.log("Glosses which match: " + morphemes[m], matchingNodes);
+              try {
+                gloss = matchingNodes[0].igt.gloss;
+              } catch (e) {
+                console.log(matchingNodes);
+              }
+            }
+            glosses.push(gloss);
+          }
+
+          glossGroups.push(glosses.join("-"));
+        }
+        datum.glossAlternates = datum.glossAlternates ? datum.glossAlternates.concat(glossGroups) : glossGroups;
+        datum.gloss = glossGroups.join(" ");
+        // Replace the gloss line with the guessed glosses
+        return datum;
+      }
+    },
+
+    /**
+     * Takes as a parameters an array of this.precedenceRelations which came from CouchDB precedence rule query.
+     * Example Rule: {"key":{"x":"@","relation":"preceeds","y":"aqtu","context":"aqtu-nay-wa-n"},"value":2}
+     */
+    generatePrecedenceForceDirectedRulesJsonForD3: {
+      value: function(dontConnectWordBoundaries) {
+        /*
+         * Cycle through the precedence rules, convert them into graph edges with the morpheme index in the morpheme array as the source/target values
+         */
+        var morphemeLinks = [];
+        var morphemes = {};
+
+
+        /*
+         * Create the JSON required by D3
+         */
+        var precedenceGraph = {
+          links: morphemeLinks,
+          nodes: morphemes
+        };
+        this.precedenceGraph = precedenceGraph;
+
+        return precedenceGraph;
+      }
+    }
+  });
+
+  var LexiconFactory = function(options) {
+    // var lex = new Lexicon(null, Lexicon.prototype.igtEqual, Lexicon.prototype.igtCompare);
+    var lex = new Lexicon();
+    lex.precedenceRelations = new UniqueSet();
+    lex.references = new UniqueSet();
+    if (options.precedenceRelations) {
+      for (var i in options.precedenceRelations) {
+        try {
+          //Add source target and value to the link
+          delete options.precedenceRelations[i].key.previous.utterance;
+          delete options.precedenceRelations[i].key.subsequent.utterance;
+          options.precedenceRelations[i].key.utteranceContext = options.precedenceRelations[i].key.context.utterance;
+          options.precedenceRelations[i].key.datumid = options.precedenceRelations[i].id;
+
+          // Put the previous and subsequent morphemes into the morpheme nodes
+          // lex.add(options.precedenceRelations[i].key.context.utterance, new LexiconNode({
+          //   igt: options.precedenceRelations[i].key.previous
+          // }));
+          lex.add(new LexiconNode({
+            igt: options.precedenceRelations[i].key.previous,
+            datumids: [options.precedenceRelations[i].key.context.id],
+            utteranceContext: [options.precedenceRelations[i].key.context.utterance],
+            url: options.url
+          }));
+
+          // lex.add(options.precedenceRelations[i].key.context.utterance, new LexiconNode({
+          //   igt: options.precedenceRelations[i].key.previous
+          // }));
+          lex.add(new LexiconNode({
+            igt: options.precedenceRelations[i].key.subsequent,
+            datumids: [options.precedenceRelations[i].key.context.id],
+            utteranceContext: [options.precedenceRelations[i].key.context.utterance],
+            url: options.url
+          }));
+          lex.references.add(options.precedenceRelations[i].key.context.id);
+
+          //To avoid loops
+          if (options.precedenceRelations[i].key.subsequent.morphemes.indexOf("@") === -1) {
+            lex.precedenceRelations.add(options.precedenceRelations[i].key);
+          }
+
+        } catch (e) {
+          console.warn(e);
+        }
+      }
+    }
+
+    for (var property in options) {
+      if (options.hasOwnProperty(property)) {
+        lex[property] = options[property];
+      }
+    }
+    return lex;
+  };
+  exports.Lexicon = Lexicon;
+  global.Lexicon = Lexicon;
+
+  exports.LexiconFactory = LexiconFactory;
+  global.LexiconFactory = LexiconFactory;
+
+}(typeof exports === 'object' && exports || this));
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../../FieldDB/api/CORS":1,"collections/set":17,"collections/sorted-set":23,"frb/bindings":29,"frb/dom":35,"q":104}],6:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+// Burgled from https://github.com/domenic/dict
+
+module.exports = Dict;
+function Dict(values, getDefault) {
+    if (!(this instanceof Dict)) {
+        return new Dict(values, getDefault);
+    }
+    getDefault = getDefault || Function.noop;
+    this.getDefault = getDefault;
+    this.store = Object.create(null);
+    this.length = 0;
+    this.addEach(values);
+}
+
+Dict.Dict = Dict; // hack so require("dict").Dict will work in MontageJS.
+
+Object.addEach(Dict.prototype, GenericCollection.prototype);
+Object.addEach(Dict.prototype, GenericMap.prototype);
+Object.addEach(Dict.prototype, PropertyChanges.prototype);
+
+Dict.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.getDefault);
+};
+
+Dict.prototype.assertString = function (key) {
+    if (typeof key !== "string") {
+        throw new TypeError("key must be a string but Got " + key);
+    }
+}
+
+Object.defineProperty(Dict.prototype,"$__proto__",{writable:true});
+Object.defineProperty(Dict.prototype,"_hasProto",{
+    get:function() {
+        return this.hasOwnProperty("$__proto__") && typeof this._protoValue !== "undefined";
+    }
+});
+Object.defineProperty(Dict.prototype,"_protoValue",{
+    get:function() {
+        return this["$__proto__"];
+    },
+    set: function(value) {
+        this["$__proto__"] = value;
+    }
+});
+
+Dict.prototype.get = function (key, defaultValue) {
+    this.assertString(key);
+    if (key === "__proto__") {
+        if (this._hasProto) {
+            return this._protoValue;
+        } else if (arguments.length > 1) {
+            return defaultValue;
+        } else {
+            return this.getDefault(key);
+        }
+    }
+    else {
+        if (key in this.store) {
+            return this.store[key];
+        } else if (arguments.length > 1) {
+            return defaultValue;
+        } else {
+            return this.getDefault(key);
+        }
+    }
+};
+
+Dict.prototype.set = function (key, value) {
+    this.assertString(key);
+    var isProtoKey = (key === "__proto__");
+    
+    if (isProtoKey ? this._hasProto : key in this.store) { // update
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, isProtoKey ? this._protoValue : this.store[key]);
+        }
+        
+        isProtoKey
+            ? this._protoValue = value
+            : this.store[key] = value;
+        
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return false;
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        this.length++;
+
+        isProtoKey
+            ? this._protoValue = value
+            : this.store[key] = value;
+
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return true;
+    }
+};
+
+Dict.prototype.has = function (key) {
+    this.assertString(key);
+    return key === "__proto__" ? this._hasProto : key in this.store;
+};
+
+Dict.prototype["delete"] = function (key) {
+    this.assertString(key);
+    if (key === "__proto__") {
+        if (this._hasProto) {
+            if (this.dispatchesMapChanges) {
+                this.dispatchBeforeMapChange(key, this._protoValue);
+            }
+            this._protoValue = undefined;
+            this.length--;
+            if (this.dispatchesMapChanges) {
+                this.dispatchMapChange(key, undefined);
+            }
+            return true;
+        }
+        return false;
+    }
+    else {
+        if (key in this.store) {
+            if (this.dispatchesMapChanges) {
+                this.dispatchBeforeMapChange(key, this.store[key]);
+            }
+            delete this.store[key];
+            this.length--;
+            if (this.dispatchesMapChanges) {
+                this.dispatchMapChange(key, undefined);
+            }
+            return true;
+        }
+        return false;
+    }
+};
+
+Dict.prototype.clear = function () {
+    var key;
+    if (this._hasProto) {
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange("__proto__", this._protoValue);
+        }
+        this._protoValue = undefined;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange("__proto__", undefined);
+        }
+    }
+    for (key in this.store) {
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[key]);
+        }
+        delete this.store[key];
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+    }
+    this.length = 0;
+};
+
+Dict.prototype.reduce = function (callback, basis, thisp) {
+    if(this._hasProto) {
+        basis = callback.call(thisp, basis, "$__proto__", "__proto__", this);
+    }
+    var store = this.store;
+    for (var key in this.store) {
+        basis = callback.call(thisp, basis, store[key], key, this);
+    }
+    return basis;
+};
+
+Dict.prototype.reduceRight = function (callback, basis, thisp) {
+    var self = this;
+    var store = this.store;
+    basis = Object.keys(this.store).reduceRight(function (basis, key) {
+        return callback.call(thisp, basis, store[key], key, self);
+    }, basis);
+    
+    if(this._hasProto) {
+        return callback.call(thisp, basis, this._protoValue, "__proto__", self);
+    }
+    return basis;
+};
+
+Dict.prototype.one = function () {
+    var key;
+    for (key in this.store) {
+        return this.store[key];
+    }
+    return this._protoValue;
+};
+
+Dict.prototype.toJSON = function () {
+    return this.toObject();
+};
+
+},{"./generic-collection":8,"./generic-map":9,"./listen/property-changes":14,"./shim":22}],7:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var Dict = require("./dict");
+var List = require("./list");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var TreeLog = require("./tree-log");
+var PropertyChanges = require("./listen/property-changes");
+
+var object_has = Object.prototype.hasOwnProperty;
+
+module.exports = FastSet;
+
+function FastSet(values, equals, hash, getDefault) {
+    if (!(this instanceof FastSet)) {
+        return new FastSet(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    var self = this;
+    this.buckets = new this.Buckets(null, function getDefaultBucket() {
+        return new self.Bucket();
+    });
+    this.length = 0;
+    this.addEach(values);
+}
+
+FastSet.FastSet = FastSet; // hack so require("fast-set").FastSet will work in MontageJS
+
+Object.addEach(FastSet.prototype, GenericCollection.prototype);
+Object.addEach(FastSet.prototype, GenericSet.prototype);
+Object.addEach(FastSet.prototype, PropertyChanges.prototype);
+
+FastSet.prototype.Buckets = Dict;
+FastSet.prototype.Bucket = List;
+
+FastSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+FastSet.prototype.has = function (value) {
+    var hash = this.contentHash(value);
+    return this.buckets.get(hash).has(value);
+};
+
+FastSet.prototype.get = function (value, equals) {
+    if (equals) {
+        throw new Error("FastSet#get does not support second argument: equals");
+    }
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        return buckets.get(hash).get(value);
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+FastSet.prototype["delete"] = function (value, equals) {
+    if (equals) {
+        throw new Error("FastSet#delete does not support second argument: equals");
+    }
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        var bucket = buckets.get(hash);
+        if (bucket["delete"](value)) {
+            this.length--;
+            if (bucket.length === 0) {
+                buckets["delete"](hash);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+FastSet.prototype.clear = function () {
+    this.buckets.clear();
+    this.length = 0;
+};
+
+FastSet.prototype.add = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (!buckets.has(hash)) {
+        buckets.set(hash, new this.Bucket(null, this.contentEquals));
+    }
+    if (!buckets.get(hash).has(value)) {
+        buckets.get(hash).add(value);
+        this.length++;
+        return true;
+    }
+    return false;
+};
+
+FastSet.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var buckets = this.buckets;
+    var index = 0;
+    return buckets.reduce(function (basis, bucket) {
+        return bucket.reduce(function (basis, value) {
+            return callback.call(thisp, basis, value, index++, this);
+        }, basis, this);
+    }, basis, this);
+};
+
+FastSet.prototype.one = function () {
+    if (this.length > 0) {
+        return this.buckets.one().one();
+    }
+};
+
+FastSet.prototype.iterate = function () {
+    return this.buckets.values().flatten().iterate();
+};
+
+FastSet.prototype.log = function (charmap, logNode, callback, thisp) {
+    charmap = charmap || TreeLog.unicodeSharp;
+    logNode = logNode || this.logNode;
+    if (!callback) {
+        callback = console.log;
+        thisp = console;
+    }
+    callback = callback.bind(thisp);
+
+    var buckets = this.buckets;
+    var hashes = buckets.keys();
+    hashes.forEach(function (hash, index) {
+        var branch;
+        var leader;
+        if (index === hashes.length - 1) {
+            branch = charmap.fromAbove;
+            leader = ' ';
+        } else if (index === 0) {
+            branch = charmap.branchDown;
+            leader = charmap.strafe;
+        } else {
+            branch = charmap.fromBoth;
+            leader = charmap.strafe;
+        }
+        var bucket = buckets.get(hash);
+        callback.call(thisp, branch + charmap.through + charmap.branchDown + ' ' + hash);
+        bucket.forEach(function (value, node) {
+            var branch, below;
+            if (node === bucket.head.prev) {
+                branch = charmap.fromAbove;
+                below = ' ';
+            } else {
+                branch = charmap.fromBoth;
+                below = charmap.strafe;
+            }
+            var written;
+            logNode(
+                node,
+                function (line) {
+                    if (!written) {
+                        callback.call(thisp, leader + ' ' + branch + charmap.through + charmap.through + line);
+                        written = true;
+                    } else {
+                        callback.call(thisp, leader + ' ' + below + '  ' + line);
+                    }
+                },
+                function (line) {
+                    callback.call(thisp, leader + ' ' + charmap.strafe + '  ' + line);
+                }
+            );
+        });
+    });
+};
+
+FastSet.prototype.logNode = function (node, write) {
+    var value = node.value;
+    if (Object(value) === value) {
+        JSON.stringify(value, null, 4).split("\n").forEach(function (line) {
+            write(" " + line);
+        });
+    } else {
+        write(" " + value);
+    }
+};
+
+
+},{"./dict":6,"./generic-collection":8,"./generic-set":11,"./list":12,"./listen/property-changes":14,"./shim":22,"./tree-log":24}],8:[function(require,module,exports){
+"use strict";
+
+module.exports = GenericCollection;
+function GenericCollection() {
+    throw new Error("Can't construct. GenericCollection is a mixin.");
+}
+
+GenericCollection.EmptyArray = Object.freeze([]);
+
+GenericCollection.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            values.forEach(this.add, this);
+        } else if (typeof values.length === "number") {
+            // Array-like objects that do not implement forEach, ergo,
+            // Arguments
+            for (var i = 0; i < values.length; i++) {
+                this.add(values[i], i);
+            }
+        } else {
+            Object.keys(values).forEach(function (key) {
+                this.add(values[key], key);
+            }, this);
+        }
+    } else if (values && typeof values.length === "number") {
+        // Strings
+        for (var i = 0; i < values.length; i++) {
+            this.add(values[i], i);
+        }
+    }
+    return this;
+};
+
+// This is sufficiently generic for Map (since the value may be a key)
+// and ordered collections (since it forwards the equals argument)
+GenericCollection.prototype.deleteEach = function (values, equals) {
+    values.forEach(function (value) {
+        this["delete"](value, equals);
+    }, this);
+    return this;
+};
+
+// all of the following functions are implemented in terms of "reduce".
+// some need "constructClone".
+
+GenericCollection.prototype.forEach = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (undefined, value, key, object, depth) {
+        callback.call(thisp, value, key, object, depth);
+    }, undefined);
+};
+
+GenericCollection.prototype.map = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = [];
+    this.reduce(function (undefined, value, key, object, depth) {
+        result.push(callback.call(thisp, value, key, object, depth));
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.enumerate = function (start) {
+    if (start == null) {
+        start = 0;
+    }
+    var result = [];
+    this.reduce(function (undefined, value) {
+        result.push([start++, value]);
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.group = function (callback, thisp, equals) {
+    equals = equals || Object.equals;
+    var groups = [];
+    var keys = [];
+    this.forEach(function (value, key, object) {
+        var key = callback.call(thisp, value, key, object);
+        var index = keys.indexOf(key, equals);
+        var group;
+        if (index === -1) {
+            group = [];
+            groups.push([key, group]);
+            keys.push(key);
+        } else {
+            group = groups[index][1];
+        }
+        group.push(value);
+    });
+    return groups;
+};
+
+GenericCollection.prototype.toArray = function () {
+    return this.map(Function.identity);
+};
+
+// this depends on stringable keys, which apply to Array and Iterator
+// because they have numeric keys and all Maps since they may use
+// strings as keys.  List, Set, and SortedSet have nodes for keys, so
+// toObject would not be meaningful.
+GenericCollection.prototype.toObject = function () {
+    var object = {};
+    this.reduce(function (undefined, value, key) {
+        object[key] = value;
+    }, undefined);
+    return object;
+};
+
+GenericCollection.prototype.filter = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = this.constructClone();
+    this.reduce(function (undefined, value, key, object, depth) {
+        if (callback.call(thisp, value, key, object, depth)) {
+            result.add(value, key);
+        }
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.every = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result && callback.call(thisp, value, key, object, depth);
+    }, true);
+};
+
+GenericCollection.prototype.some = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result || callback.call(thisp, value, key, object, depth);
+    }, false);
+};
+
+GenericCollection.prototype.all = function () {
+    return this.every(Boolean);
+};
+
+GenericCollection.prototype.any = function () {
+    return this.some(Boolean);
+};
+
+GenericCollection.prototype.min = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) < 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.max = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) > 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.sum = function (zero) {
+    zero = zero === undefined ? 0 : zero;
+    return this.reduce(function (a, b) {
+        return a + b;
+    }, zero);
+};
+
+GenericCollection.prototype.average = function (zero) {
+    var sum = zero === undefined ? 0 : zero;
+    var count = zero === undefined ? 0 : zero;
+    this.reduce(function (undefined, value) {
+        sum += value;
+        count += 1;
+    }, undefined);
+    return sum / count;
+};
+
+GenericCollection.prototype.concat = function () {
+    var result = this.constructClone(this);
+    for (var i = 0; i < arguments.length; i++) {
+        result.addEach(arguments[i]);
+    }
+    return result;
+};
+
+GenericCollection.prototype.flatten = function () {
+    var self = this;
+    return this.reduce(function (result, array) {
+        array.forEach(function (value) {
+            this.push(value);
+        }, result, self);
+        return result;
+    }, []);
+};
+
+GenericCollection.prototype.zip = function () {
+    var table = Array.prototype.slice.call(arguments);
+    table.unshift(this);
+    return Array.unzip(table);
+}
+
+GenericCollection.prototype.join = function (delimiter) {
+    return this.reduce(function (result, string) {
+        // work-around for reduce that does not support no-basis form
+        if (result === void 0) {
+            return string;
+        } else {
+            return result + delimiter + string;
+        }
+    }, void 0);
+};
+
+GenericCollection.prototype.sorted = function (compare, by, order) {
+    compare = compare || this.contentCompare || Object.compare;
+    // account for comparators generated by Function.by
+    if (compare.by) {
+        by = compare.by;
+        compare = compare.compare || this.contentCompare || Object.compare;
+    } else {
+        by = by || Function.identity;
+    }
+    if (order === undefined)
+        order = 1;
+    return this.map(function (item) {
+        return {
+            by: by(item),
+            value: item
+        };
+    })
+    .sort(function (a, b) {
+        return compare(a.by, b.by) * order;
+    })
+    .map(function (pair) {
+        return pair.value;
+    });
+};
+
+GenericCollection.prototype.reversed = function () {
+    return this.constructClone(this).reverse();
+};
+
+GenericCollection.prototype.clone = function (depth, memo) {
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return this;
+    }
+    var clone = this.constructClone();
+    this.forEach(function (value, key) {
+        clone.add(Object.clone(value, depth - 1, memo), key);
+    }, this);
+    return clone;
+};
+
+GenericCollection.prototype.only = function () {
+    if (this.length === 1) {
+        return this.one();
+    }
+};
+
+GenericCollection.prototype.iterator = function () {
+    return this.iterate.apply(this, arguments);
+};
+
+require("./shim-array");
+
+
+},{"./shim-array":18}],9:[function(require,module,exports){
+"use strict";
+
+var Object = require("./shim-object");
+var MapChanges = require("./listen/map-changes");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = GenericMap;
+function GenericMap() {
+    throw new Error("Can't construct. GenericMap is a mixin.");
+}
+
+Object.addEach(GenericMap.prototype, MapChanges.prototype);
+Object.addEach(GenericMap.prototype, PropertyChanges.prototype);
+
+// all of these methods depend on the constructor providing a `store` set
+
+GenericMap.prototype.isMap = true;
+
+GenericMap.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            // copy map-alikes
+            if (values.isMap === true) {
+                values.forEach(function (value, key) {
+                    this.set(key, value);
+                }, this);
+            // iterate key value pairs of other iterables
+            } else {
+                values.forEach(function (pair) {
+                    this.set(pair[0], pair[1]);
+                }, this);
+            }
+        } else if (typeof values.length === "number") {
+            // Array-like objects that do not implement forEach, ergo,
+            // Arguments
+            for (var i = 0; i < values.length; i++) {
+                this.add(values[i], i);
+            }
+        } else {
+            // copy other objects as map-alikes
+            Object.keys(values).forEach(function (key) {
+                this.set(key, values[key]);
+            }, this);
+        }
+    } else if (values && typeof values.length === "number") {
+        // String
+        for (var i = 0; i < values.length; i++) {
+            this.add(values[i], i);
+        }
+    }
+    return this;
+}
+
+GenericMap.prototype.get = function (key, defaultValue) {
+    var item = this.store.get(new this.Item(key));
+    if (item) {
+        return item.value;
+    } else if (arguments.length > 1) {
+        return defaultValue;
+    } else {
+        return this.getDefault(key);
+    }
+};
+
+GenericMap.prototype.set = function (key, value) {
+    var item = new this.Item(key, value);
+    var found = this.store.get(item);
+    var grew = false;
+    if (found) { // update
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, found.value);
+        }
+        found.value = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        if (this.store.add(item)) {
+            this.length++;
+            grew = true;
+        }
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    }
+    return grew;
+};
+
+GenericMap.prototype.add = function (value, key) {
+    return this.set(key, value);
+};
+
+GenericMap.prototype.has = function (key) {
+    return this.store.has(new this.Item(key));
+};
+
+GenericMap.prototype['delete'] = function (key) {
+    var item = new this.Item(key);
+    if (this.store.has(item)) {
+        var from = this.store.get(item).value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, from);
+        }
+        this.store["delete"](item);
+        this.length--;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+        return true;
+    }
+    return false;
+};
+
+GenericMap.prototype.clear = function () {
+    var keys;
+    if (this.dispatchesMapChanges) {
+        this.forEach(function (value, key) {
+            this.dispatchBeforeMapChange(key, value);
+        }, this);
+        keys = this.keys();
+    }
+    this.store.clear();
+    this.length = 0;
+    if (this.dispatchesMapChanges) {
+        keys.forEach(function (key) {
+            this.dispatchMapChange(key);
+        }, this);
+    }
+};
+
+GenericMap.prototype.reduce = function (callback, basis, thisp) {
+    return this.store.reduce(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.reduceRight = function (callback, basis, thisp) {
+    return this.store.reduceRight(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.keys = function () {
+    return this.map(function (value, key) {
+        return key;
+    });
+};
+
+GenericMap.prototype.values = function () {
+    return this.map(Function.identity);
+};
+
+GenericMap.prototype.entries = function () {
+    return this.map(function (value, key) {
+        return [key, value];
+    });
+};
+
+// XXX deprecated
+GenericMap.prototype.items = function () {
+    return this.entries();
+};
+
+GenericMap.prototype.equals = function (that, equals) {
+    equals = equals || Object.equals;
+    if (this === that) {
+        return true;
+    } else if (that && typeof that.every === "function") {
+        return that.length === this.length && that.every(function (value, key) {
+            return equals(this.get(key), value);
+        }, this);
+    } else {
+        var keys = Object.keys(that);
+        return keys.length === this.length && Object.keys(that).every(function (key) {
+            return equals(this.get(key), that[key]);
+        }, this);
+    }
+};
+
+GenericMap.prototype.toJSON = function () {
+    return this.entries();
+};
+
+GenericMap.prototype.Item = Item;
+
+function Item(key, value) {
+    this.key = key;
+    this.value = value;
+}
+
+Item.prototype.equals = function (that) {
+    return Object.equals(this.key, that.key) && Object.equals(this.value, that.value);
+};
+
+Item.prototype.compare = function (that) {
+    return Object.compare(this.key, that.key);
+};
+
+
+},{"./listen/map-changes":13,"./listen/property-changes":14,"./shim-object":20}],10:[function(require,module,exports){
+
+var Object = require("./shim-object");
+
+module.exports = GenericOrder;
+function GenericOrder() {
+    throw new Error("Can't construct. GenericOrder is a mixin.");
+}
+
+GenericOrder.prototype.equals = function (that, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+
+    if (this === that) {
+        return true;
+    }
+    if (!that) {
+        return false;
+    }
+
+    var self = this;
+    return (
+        this.length === that.length &&
+        this.zip(that).every(function (pair) {
+            return equals(pair[0], pair[1]);
+        })
+    );
+};
+
+GenericOrder.prototype.compare = function (that, compare) {
+    compare = compare || this.contentCompare || Object.compare;
+
+    if (this === that) {
+        return 0;
+    }
+    if (!that) {
+        return 1;
+    }
+
+    var length = Math.min(this.length, that.length);
+    var comparison = this.zip(that).reduce(function (comparison, pair, index) {
+        if (comparison === 0) {
+            if (index >= length) {
+                return comparison;
+            } else {
+                return compare(pair[0], pair[1]);
+            }
+        } else {
+            return comparison;
+        }
+    }, 0);
+    if (comparison === 0) {
+        return this.length - that.length;
+    }
+    return comparison;
+};
+
+GenericOrder.prototype.toJSON = function () {
+    return this.toArray();
+};
+
+},{"./shim-object":20}],11:[function(require,module,exports){
+
+module.exports = GenericSet;
+function GenericSet() {
+    throw new Error("Can't construct. GenericSet is a mixin.");
+}
+
+GenericSet.prototype.isSet = true;
+
+GenericSet.prototype.union = function (that) {
+    var union =  this.constructClone(this);
+    union.addEach(that);
+    return union;
+};
+
+GenericSet.prototype.intersection = function (that) {
+    return this.constructClone(this.filter(function (value) {
+        return that.has(value);
+    }));
+};
+
+GenericSet.prototype.difference = function (that) {
+    var union =  this.constructClone(this);
+    union.deleteEach(that);
+    return union;
+};
+
+GenericSet.prototype.symmetricDifference = function (that) {
+    var union = this.union(that);
+    var intersection = this.intersection(that);
+    return union.difference(intersection);
+};
+
+GenericSet.prototype.deleteAll = function (value) {
+    // deleteAll is equivalent to delete for sets since they guarantee that
+    // only one value exists for an equivalence class, but deleteAll returns
+    // the count of deleted values instead of whether a value was deleted.
+    return +this["delete"](value);
+};
+
+GenericSet.prototype.equals = function (that, equals) {
+    var self = this;
+    return (
+        that && typeof that.reduce === "function" &&
+        this.length === that.length &&
+        that.reduce(function (equal, value) {
+            return equal && self.has(value, equals);
+        }, true)
+    );
+};
+
+GenericSet.prototype.toJSON = function () {
+    return this.toArray();
+};
+
+// W3C DOMTokenList API overlap (does not handle variadic arguments)
+
+GenericSet.prototype.contains = function (value) {
+    return this.has(value);
+};
+
+GenericSet.prototype.remove = function (value) {
+    return this["delete"](value);
+};
+
+GenericSet.prototype.toggle = function (value) {
+    if (this.has(value)) {
+        this["delete"](value);
+    } else {
+        this.add(value);
+    }
+};
+
+
+},{}],12:[function(require,module,exports){
+"use strict";
+
+module.exports = List;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericOrder = require("./generic-order");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+function List(values, equals, getDefault) {
+    if (!(this instanceof List)) {
+        return new List(values, equals, getDefault);
+    }
+    var head = this.head = new this.Node();
+    head.next = head;
+    head.prev = head;
+    this.contentEquals = equals || Object.equals;
+    this.getDefault = getDefault || Function.noop;
+    this.length = 0;
+    this.addEach(values);
+}
+
+List.List = List; // hack so require("list").List will work in MontageJS
+
+Object.addEach(List.prototype, GenericCollection.prototype);
+Object.addEach(List.prototype, GenericOrder.prototype);
+Object.addEach(List.prototype, PropertyChanges.prototype);
+Object.addEach(List.prototype, RangeChanges.prototype);
+
+List.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.contentEquals, this.getDefault);
+};
+
+List.prototype.find = function (value, equals, index) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = this.scan(index, head.next);
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.next;
+    }
+};
+
+List.prototype.findLast = function (value, equals, index) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = this.scan(index, head.prev);
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.prev;
+    }
+};
+
+List.prototype.has = function (value, equals) {
+    return !!this.find(value, equals);
+};
+
+List.prototype.get = function (value, equals) {
+    var found = this.find(value, equals);
+    if (found) {
+        return found.value;
+    }
+    return this.getDefault(value);
+};
+
+// LIFO (delete removes the most recently added equivalent value)
+List.prototype["delete"] = function (value, equals) {
+    var found = this.findLast(value, equals);
+    if (found) {
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, found.index);
+        }
+        found["delete"]();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(found.next, found.index);
+            this.dispatchRangeChange(plus, minus, found.index);
+        }
+        return true;
+    }
+    return false;
+};
+
+List.prototype.deleteAll = function (value, equals) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = head.next;
+    var count = 0;
+    while (at !== head) {
+        if (equals(value, at.value)) {
+            at["delete"]();
+            count++;
+        }
+        at = at.next;
+    }
+    this.length -= count;
+    return count;
+};
+
+List.prototype.clear = function () {
+    var plus, minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.toArray();
+        plus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    this.head.next = this.head.prev = this.head;
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.add = function (value) {
+    var node = new this.Node(value)
+    if (this.dispatchesRangeChanges) {
+        node.index = this.length;
+        this.dispatchBeforeRangeChange([value], [], node.index);
+    }
+    this.head.addBefore(node);
+    this.length++;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([value], [], node.index);
+    }
+    return true;
+};
+
+List.prototype.push = function () {
+    var head = this.head;
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = []
+        var index = this.length;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+        var start = this.head.prev;
+    }
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        head.addBefore(node);
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(start.next, start.index === undefined ? 0 : start.index + 1);
+        this.dispatchRangeChange(plus, minus, index);
+    }
+};
+
+List.prototype.unshift = function () {
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        at.addAfter(node);
+        at = node;
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(this.head.next, 0);
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.pop = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.prev.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            var index = this.length - 1;
+            this.dispatchBeforeRangeChange(plus, minus, index);
+        }
+        head.prev['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange(plus, minus, index);
+        }
+    }
+    return value;
+};
+
+List.prototype.shift = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.next.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, 0);
+        }
+        head.next['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(this.head.next, 0);
+            this.dispatchRangeChange(plus, minus, 0);
+        }
+    }
+    return value;
+};
+
+List.prototype.peek = function () {
+    if (this.head !== this.head.next) {
+        return this.head.next.value;
+    }
+};
+
+List.prototype.poke = function (value) {
+    if (this.head !== this.head.next) {
+        this.head.next.value = value;
+    } else {
+        this.push(value);
+    }
+};
+
+List.prototype.one = function () {
+    return this.peek();
+};
+
+// TODO
+// List.prototype.indexOf = function (value) {
+// };
+
+// TODO
+// List.prototype.lastIndexOf = function (value) {
+// };
+
+// an internal utility for coercing index offsets to nodes
+List.prototype.scan = function (at, fallback) {
+    var head = this.head;
+    if (typeof at === "number") {
+        var count = at;
+        if (count >= 0) {
+            at = head.next;
+            while (count) {
+                count--;
+                at = at.next;
+                if (at == head) {
+                    break;
+                }
+            }
+        } else {
+            at = head;
+            while (count < 0) {
+                count++;
+                at = at.prev;
+                if (at == head) {
+                    break;
+                }
+            }
+        }
+        return at;
+    } else {
+        return at || fallback;
+    }
+};
+
+// at and end may both be positive or negative numbers (in which cases they
+// correspond to numeric indicies, or nodes)
+List.prototype.slice = function (at, end) {
+    var sliced = [];
+    var head = this.head;
+    at = this.scan(at, head.next);
+    end = this.scan(end, head);
+
+    while (at !== end && at !== head) {
+        sliced.push(at.value);
+        at = at.next;
+    }
+
+    return sliced;
+};
+
+List.prototype.splice = function (at, length /*...plus*/) {
+    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
+};
+
+List.prototype.swap = function (start, length, plus) {
+    var initial = start;
+    // start will be head if start is null or -1 (meaning from the end), but
+    // will be head.next if start is 0 (meaning from the beginning)
+    start = this.scan(start, this.head);
+    if (length == null) {
+        length = Infinity;
+    }
+    plus = Array.from(plus);
+
+    // collect the minus array
+    var minus = [];
+    var at = start;
+    while (length-- && length >= 0 && at !== this.head) {
+        minus.push(at.value);
+        at = at.next;
+    }
+
+    // before range change
+    var index, startNode;
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            index = this.length;
+        } else if (start.prev === this.head) {
+            index = 0;
+        } else {
+            index = start.index;
+        }
+        startNode = start.prev;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+    }
+
+    // delete minus
+    var at = start;
+    for (var i = 0, at = start; i < minus.length; i++, at = at.next) {
+        at["delete"]();
+    }
+    // add plus
+    if (initial == null && at === this.head) {
+        at = this.head.next;
+    }
+    for (var i = 0; i < plus.length; i++) {
+        var node = new this.Node(plus[i]);
+        at.addBefore(node);
+    }
+    // adjust length
+    this.length += plus.length - minus.length;
+
+    // after range change
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            this.updateIndexes(this.head.next, 0);
+        } else {
+            this.updateIndexes(startNode.next, startNode.index + 1);
+        }
+        this.dispatchRangeChange(plus, minus, index);
+    }
+
+    return minus;
+};
+
+List.prototype.reverse = function () {
+    if (this.dispatchesRangeChanges) {
+        var minus = this.toArray();
+        var plus = minus.reversed();
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    do {
+        var temp = at.next;
+        at.next = at.prev;
+        at.prev = temp;
+        at = at.next;
+    } while (at !== this.head);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+    return this;
+};
+
+List.prototype.sort = function () {
+    this.swap(0, this.length, this.sorted());
+};
+
+// TODO account for missing basis argument
+List.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.next;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.next;
+    }
+    return basis;
+};
+
+List.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.prev;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.prev;
+    }
+    return basis;
+};
+
+List.prototype.updateIndexes = function (node, index) {
+    while (node !== this.head) {
+        node.index = index++;
+        node = node.next;
+    }
+};
+
+List.prototype.makeObservable = function () {
+    this.head.index = -1;
+    this.updateIndexes(this.head.next, 0);
+    this.dispatchesRangeChanges = true;
+};
+
+List.prototype.iterate = function () {
+    return new ListIterator(this.head);
+};
+
+function ListIterator(head) {
+    this.head = head;
+    this.at = head.next;
+};
+
+ListIterator.prototype.next = function () {
+    if (this.at === this.head) {
+        throw StopIteration;
+    } else {
+        var value = this.at.value;
+        this.at = this.at.next;
+        return value;
+    }
+};
+
+List.prototype.Node = Node;
+
+function Node(value) {
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+};
+
+Node.prototype["delete"] = function () {
+    this.prev.next = this.next;
+    this.next.prev = this.prev;
+};
+
+Node.prototype.addBefore = function (node) {
+    var prev = this.prev;
+    this.prev = node;
+    node.prev = prev;
+    prev.next = node;
+    node.next = this;
+};
+
+Node.prototype.addAfter = function (node) {
+    var next = this.next;
+    this.next = node;
+    node.next = next;
+    next.prev = node;
+    node.prev = this;
+};
+
+
+},{"./generic-collection":8,"./generic-order":10,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22}],13:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+var List = require("../list");
+
+module.exports = MapChanges;
+function MapChanges() {
+    throw new Error("Can't construct. MapChanges is a mixin.");
+}
+
+var object_owns = Object.prototype.hasOwnProperty;
+
+/*
+    Object map change descriptors carry information necessary for adding,
+    removing, dispatching, and shorting events to listeners for map changes
+    for a particular key on a particular object.  These descriptors are used
+    here for shallow map changes.
+
+    {
+        willChangeListeners:Array(Function)
+        changeListeners:Array(Function)
+    }
+*/
+
+var mapChangeDescriptors = new WeakMap();
+var Dict = null;
+
+MapChanges.prototype.getAllMapChangeDescriptors = function () {
+    if (!mapChangeDescriptors.has(this)) {
+        if (!Dict) {
+            Dict = require("../dict");
+        }
+        mapChangeDescriptors.set(this, Dict());
+    }
+    return mapChangeDescriptors.get(this);
+};
+
+MapChanges.prototype.getMapChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllMapChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            willChangeListeners: new List(),
+            changeListeners: new List()
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+MapChanges.prototype.addMapChangeListener = function (listener, token, beforeChange) {
+    if (!this.isObservable && this.makeObservable) {
+        // for Array
+        this.makeObservable();
+    }
+    var descriptor = this.getMapChangeDescriptor(token);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesMapChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelMapChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Can't remove map change listener again");
+            return;
+        }
+        self.removeMapChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+MapChanges.prototype.removeMapChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getMapChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var node = listeners.findLast(listener);
+    if (!node) {
+        throw new Error("Can't remove map change listener: does not exist: token " + JSON.stringify(token));
+    }
+    node["delete"]();
+};
+
+MapChanges.prototype.dispatchMapChange = function (key, value, beforeChange) {
+    var descriptors = this.getAllMapChangeDescriptors();
+    var changeName = "Map" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+
+        try {
+            // dispatch to each listener
+            listeners.forEach(function (listener) {
+                if (listener[tokenName]) {
+                    listener[tokenName](value, key, this);
+                } else if (listener.call) {
+                    listener.call(listener, value, key, this);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+
+    }, this);
+};
+
+MapChanges.prototype.addBeforeMapChangeListener = function (listener, token) {
+    return this.addMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.removeBeforeMapChangeListener = function (listener, token) {
+    return this.removeMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.dispatchBeforeMapChange = function (key, value) {
+    return this.dispatchMapChange(key, value, true);
+};
+
+
+},{"../dict":6,"../list":12,"weak-map":16}],14:[function(require,module,exports){
+/*
+    Based in part on observable arrays from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/*
+    This module is responsible for observing changes to owned properties of
+    objects and changes to the content of arrays caused by method calls.
+    The interface for observing array content changes establishes the methods
+    necessary for any collection with observable content.
+*/
+
+require("../shim");
+
+// objectHasOwnProperty.call(myObject, key) will be used instead of
+// myObject.hasOwnProperty(key) to allow myObject have defined
+// a own property called "hasOwnProperty".
+
+var objectHasOwnProperty = Object.prototype.hasOwnProperty;
+
+// Object property descriptors carry information necessary for adding,
+// removing, dispatching, and shorting events to listeners for property changes
+// for a particular key on a particular object.  These descriptors are used
+// here for shallow property changes.  The current listeners are the ones
+// modified by add and remove own property change listener methods.  During
+// property change dispatch, we capture a snapshot of the current listeners in
+// the active change listeners array.  The descriptor also keeps a memo of the
+// corresponding handler method names.
+//
+// {
+//     willChangeListeners:{current, active:Array<Function>, ...method names}
+//     changeListeners:{current, active:Array<Function>, ...method names}
+// }
+
+// Maybe remove entries from this table if the corresponding object no longer
+// has any property change listeners for any key.  However, the cost of
+// book-keeping is probably not warranted since it would be rare for an
+// observed object to no longer be observed unless it was about to be disposed
+// of or reused as an observable.  The only benefit would be in avoiding bulk
+// calls to dispatchOwnPropertyChange events on objects that have no listeners.
+
+//  To observe shallow property changes for a particular key of a particular
+//  object, we install a property descriptor on the object that overrides the previous
+//  descriptor.  The overridden descriptors are stored in this weak map.  The
+//  weak map associates an object with another object that maps property names
+//  to property descriptors.
+//
+//  object.__overriddenPropertyDescriptors__[key]
+//
+//  We retain the old descriptor for various purposes.  For one, if the property
+//  is no longer being observed by anyone, we revert the property descriptor to
+//  the original.  For "value" descriptors, we store the actual value of the
+//  descriptor on the overridden descriptor, so when the property is reverted, it
+//  retains the most recently set value.  For "get" and "set" descriptors,
+//  we observe then forward "get" and "set" operations to the original descriptor.
+
+module.exports = PropertyChanges;
+
+function PropertyChanges() {
+    throw new Error("This is an abstract interface. Mix it. Don't construct it");
+}
+
+PropertyChanges.debug = true;
+
+PropertyChanges.prototype.getOwnPropertyChangeDescriptor = function (key) {
+    if (!this.__propertyChangeListeners__) {
+        Object.defineProperty(this, "__propertyChangeListeners__", {
+            value: {},
+            enumerable: false,
+            configurable: true,
+            writable: true
+        });
+    }
+    var objectPropertyChangeDescriptors = this.__propertyChangeListeners__;
+    if (!objectHasOwnProperty.call(objectPropertyChangeDescriptors, key)) {
+        var propertyName = String(key);
+
+        propertyName = propertyName && propertyName[0].toUpperCase() + propertyName.slice(1);
+        objectPropertyChangeDescriptors[key] = {
+            willChangeListeners: {
+                current: [],
+                active: [],
+                specificHandlerMethodName: "handle" + propertyName + "WillChange",
+                genericHandlerMethodName: "handlePropertyWillChange"
+            },
+            changeListeners: {
+                current: [],
+                active: [],
+                specificHandlerMethodName: "handle" + propertyName + "Change",
+                genericHandlerMethodName: "handlePropertyChange"
+            }
+        };
+    }
+    return objectPropertyChangeDescriptors[key];
+};
+
+PropertyChanges.prototype.hasOwnPropertyChangeDescriptor = function (key) {
+    if (!this.__propertyChangeListeners__) {
+        return false;
+    }
+    if (!key) {
+        return true;
+    }
+    var objectPropertyChangeDescriptors = this.__propertyChangeListeners__;
+    if (!objectHasOwnProperty.call(objectPropertyChangeDescriptors, key)) {
+        return false;
+    }
+    return true;
+};
+
+PropertyChanges.prototype.addOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    if (this.makeObservable && !this.isObservable) {
+        this.makeObservable(); // particularly for observable arrays, for
+        // their length property
+    }
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    PropertyChanges.makePropertyObservable(this, key);
+    listeners.current.push(listener);
+
+    var self = this;
+    return function cancelOwnPropertyChangeListener() {
+        PropertyChanges.removeOwnPropertyChangeListener(self, key, listener, beforeChange);
+        self = null;
+    };
+};
+
+PropertyChanges.prototype.addBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.removeOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.current.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove property change listener: does not exist: property name" + JSON.stringify(key));
+    }
+    listeners.current.splice(index, 1);
+};
+
+PropertyChanges.prototype.removeBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.dispatchOwnPropertyChange = function (key, value, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key),
+        listeners;
+
+    if (!descriptor.isActive) {
+        descriptor.isActive = true;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+        try {
+            dispatchEach(listeners, key, value, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+    }
+};
+
+function dispatchEach(listeners, key, value, object) {
+    // copy snapshot of current listeners to active listeners
+    var active = listeners.active;
+    var current = listeners.current;
+    var index = current.length;
+    var listener, length = index, i, thisp;
+
+    if (active.length > index) {
+        active.length = index;
+    }
+    while (index--) {
+        active[index] = current[index];
+    }
+    for (i = 0; i < length; i++) {
+        thisp = active[i];
+        //This is fixing the issue causing a regression in Montage's repetition
+        if (!i || current.indexOf(thisp) >= 0) {
+            listener = (
+                thisp[listeners.specificHandlerMethodName] ||
+                thisp[listeners.genericHandlerMethodName] ||
+                thisp
+            );
+            if (!listener.call) {
+                throw new Error("No event listener for " + listeners.specificHandlerName + " or " + listeners.genericHandlerName + " or call on " + listener);
+            }
+            listener.call(thisp, value, key, object);
+        }
+
+    }
+}
+
+PropertyChanges.prototype.dispatchBeforeOwnPropertyChange = function (key, listener) {
+    return PropertyChanges.dispatchOwnPropertyChange(this, key, listener, true);
+};
+
+PropertyChanges.prototype.makePropertyObservable = function (key) {
+    // arrays are special.  we do not support direct setting of properties
+    // on an array.  instead, call .set(index, value).  this is observable.
+    // 'length' property is observable for all mutating methods because
+    // our overrides explicitly dispatch that change.
+
+
+    var overriddenPropertyDescriptors = this.__overriddenPropertyDescriptors__;
+
+    // memoize overridden property descriptor table
+    if (!overriddenPropertyDescriptors) {
+        if (Array.isArray(this)) {
+            return;
+        }
+        if (!Object.isExtensible(this)) {
+            throw new Error("Can't make property " + JSON.stringify(key) + " observable on " + this + " because object is not extensible");
+        }
+        overriddenPropertyDescriptors = {};
+        Object.defineProperty(this, "__overriddenPropertyDescriptors__", {
+            value: overriddenPropertyDescriptors,
+            enumerable: false,
+            writable: true,
+            configurable: true
+        });
+    } else {
+        if (objectHasOwnProperty.call(overriddenPropertyDescriptors, key)) {
+            // if we have already recorded an overridden property descriptor,
+            // we have already installed the observer, so short-here
+            return;
+        }
+    }
+
+    var state;
+    if (typeof this.__state__ === "object") {
+        state = this.__state__;
+    } else {
+        state = {};
+        Object.defineProperty(this, "__state__", {
+            value: state,
+            writable: true,
+            enumerable: false
+        });
+    }
+    state[key] = this[key];
+
+
+
+    // walk up the prototype chain to find a property descriptor for
+    // the property name
+    var overriddenDescriptor;
+    var attached = this;
+    do {
+        overriddenDescriptor = Object.getOwnPropertyDescriptor(attached, key);
+        if (overriddenDescriptor) {
+            break;
+        }
+        attached = Object.getPrototypeOf(attached);
+    } while (attached);
+    // or default to an undefined value
+    if (!overriddenDescriptor) {
+        overriddenDescriptor = {
+            value: undefined,
+            enumerable: true,
+            writable: true,
+            configurable: true
+        };
+    } else {
+        if (!overriddenDescriptor.configurable) {
+            return;
+        }
+        if (!overriddenDescriptor.writable && !overriddenDescriptor.set) {
+            return;
+        }
+    }
+
+    // memoize the descriptor so we know not to install another layer,
+    // and so we can reuse the overridden descriptor when uninstalling
+    overriddenPropertyDescriptors[key] = overriddenDescriptor;
+
+
+    // TODO reflect current value on a displayed property
+
+    var propertyListener;
+    // in both of these new descriptor variants, we reuse the overridden
+    // descriptor to either store the current value or apply getters
+    // and setters.  this is handy since we can reuse the overridden
+    // descriptor if we uninstall the observer.  We even preserve the
+    // assignment semantics, where we get the value from up the
+    // prototype chain, and set as an owned property.
+    if ('value' in overriddenDescriptor) {
+        propertyListener = {
+            get: function () {
+                return overriddenDescriptor.value;
+            },
+            set: function (value) {
+                var descriptor,
+                    isActive;
+
+                if (value !== overriddenDescriptor.value) {
+                    descriptor = this.__propertyChangeListeners__[key];
+                    isActive = descriptor.isActive;
+                    if (!isActive) {
+                        descriptor.isActive = true;
+                        try {
+                            dispatchEach(descriptor.willChangeListeners, key, overriddenDescriptor.value, this);
+                        } finally {}
+                    }
+                    overriddenDescriptor.value = value;
+                    state[key] = value;
+                    if (!isActive) {
+                        try {
+                            dispatchEach(descriptor.changeListeners, key, value, this);
+                        } finally {
+                            descriptor.isActive = false;
+                        }
+                    }
+                }
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    } else { // 'get' or 'set', but not necessarily both
+        propertyListener = {
+            get: overriddenDescriptor.get,
+            set: function (value) {
+                var formerValue = this[key],
+                    descriptor,
+                    isActive;
+
+                overriddenDescriptor.set.call(this, value);
+                value = this[key];
+                if (value !== formerValue) {
+                    descriptor = this.__propertyChangeListeners__[key];
+                    isActive = descriptor.isActive;
+                    if (!isActive) {
+                        descriptor.isActive = true;
+                        try {
+                            dispatchEach(descriptor.willChangeListeners, key, formerValue, this);
+                        } finally {}
+                    }
+                    state[key] = value;
+                    if (!isActive) {
+                        try {
+                            dispatchEach(descriptor.changeListeners, key, value, this);
+                        } finally {
+                            descriptor.isActive = false;
+                        }
+                    }
+                }
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    }
+
+    Object.defineProperty(this, key, propertyListener);
+};
+
+// constructor functions
+
+PropertyChanges.getOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.getOwnPropertyChangeDescriptor) {
+        return object.getOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.getOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.hasOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.hasOwnPropertyChangeDescriptor) {
+        return object.hasOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.hasOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.addOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.addOwnPropertyChangeListener) {
+        return object.addOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.addOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.removeOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.removeOwnPropertyChangeListener) {
+        return object.removeOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.removeOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.dispatchOwnPropertyChange = function (object, key, value, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.dispatchOwnPropertyChange) {
+        return object.dispatchOwnPropertyChange(key, value, beforeChange);
+    } else {
+        return PropertyChanges.prototype.dispatchOwnPropertyChange.call(object, key, value, beforeChange);
+    }
+};
+
+PropertyChanges.addBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.removeBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.dispatchBeforeOwnPropertyChange = function (object, key, value) {
+    return PropertyChanges.dispatchOwnPropertyChange(object, key, value, true);
+};
+
+PropertyChanges.makePropertyObservable = function (object, key) {
+    if (object.makePropertyObservable) {
+        return object.makePropertyObservable(key);
+    } else {
+        return PropertyChanges.prototype.makePropertyObservable.call(object, key);
+    }
+};
+
+},{"../shim":22}],15:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+var Dict = require("../dict");
+
+var rangeChangeDescriptors = new WeakMap(); // {isActive, willChangeListeners, changeListeners}
+
+module.exports = RangeChanges;
+function RangeChanges() {
+    throw new Error("Can't construct. RangeChanges is a mixin.");
+}
+
+RangeChanges.prototype.getAllRangeChangeDescriptors = function () {
+    if (!rangeChangeDescriptors.has(this)) {
+        rangeChangeDescriptors.set(this, Dict());
+    }
+    return rangeChangeDescriptors.get(this);
+};
+
+RangeChanges.prototype.getRangeChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllRangeChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            isActive: false,
+            changeListeners: [],
+            willChangeListeners: []
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+RangeChanges.prototype.addRangeChangeListener = function (listener, token, beforeChange) {
+    // a concession for objects like Array that are not inherently observable
+    if (!this.isObservable && this.makeObservable) {
+        this.makeObservable();
+    }
+
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    // even if already registered
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesRangeChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelRangeChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Range change listener " + JSON.stringify(token) + " has already been canceled");
+            return;
+        }
+        self.removeRangeChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+RangeChanges.prototype.removeRangeChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove range change listener: does not exist: token " + JSON.stringify(token));
+    }
+    listeners.splice(index, 1);
+};
+
+RangeChanges.prototype.dispatchRangeChange = function (plus, minus, index, beforeChange) {
+    var descriptors = this.getAllRangeChangeDescriptors();
+    var changeName = "Range" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        // before or after
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+        // notably, defaults to "handleRangeChange" or "handleRangeWillChange"
+        // if token is "" (the default)
+
+        // dispatch each listener
+        try {
+            listeners.slice().forEach(function (listener) {
+                if (listeners.indexOf(listener) < 0) {
+                    return;
+                }
+                if (listener[tokenName]) {
+                    listener[tokenName](plus, minus, index, this, beforeChange);
+                } else if (listener.call) {
+                    listener.call(this, plus, minus, index, this, beforeChange);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+    }, this);
+};
+
+RangeChanges.prototype.addBeforeRangeChangeListener = function (listener, token) {
+    return this.addRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.removeBeforeRangeChangeListener = function (listener, token) {
+    return this.removeRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.dispatchBeforeRangeChange = function (plus, minus, index) {
+    return this.dispatchRangeChange(plus, minus, index, true);
+};
+
+
+},{"../dict":6,"weak-map":16}],16:[function(require,module,exports){
+// Copyright (C) 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Install a leaky WeakMap emulation on platforms that
+ * don't provide a built-in one.
+ *
+ * <p>Assumes that an ES5 platform where, if {@code WeakMap} is
+ * already present, then it conforms to the anticipated ES6
+ * specification. To run this file on an ES5 or almost ES5
+ * implementation where the {@code WeakMap} specification does not
+ * quite conform, run <code>repairES5.js</code> first.
+ *
+ * <p>Even though WeakMapModule is not global, the linter thinks it
+ * is, which is why it is in the overrides list below.
+ *
+ * <p>NOTE: Before using this WeakMap emulation in a non-SES
+ * environment, see the note below about hiddenRecord.
+ *
+ * @author Mark S. Miller
+ * @requires crypto, ArrayBuffer, Uint8Array, navigator, console
+ * @overrides WeakMap, ses, Proxy
+ * @overrides WeakMapModule
+ */
+
+/**
+ * This {@code WeakMap} emulation is observably equivalent to the
+ * ES-Harmony WeakMap, but with leakier garbage collection properties.
+ *
+ * <p>As with true WeakMaps, in this emulation, a key does not
+ * retain maps indexed by that key and (crucially) a map does not
+ * retain the keys it indexes. A map by itself also does not retain
+ * the values associated with that map.
+ *
+ * <p>However, the values associated with a key in some map are
+ * retained so long as that key is retained and those associations are
+ * not overridden. For example, when used to support membranes, all
+ * values exported from a given membrane will live for the lifetime
+ * they would have had in the absence of an interposed membrane. Even
+ * when the membrane is revoked, all objects that would have been
+ * reachable in the absence of revocation will still be reachable, as
+ * far as the GC can tell, even though they will no longer be relevant
+ * to ongoing computation.
+ *
+ * <p>The API implemented here is approximately the API as implemented
+ * in FF6.0a1 and agreed to by MarkM, Andreas Gal, and Dave Herman,
+ * rather than the offially approved proposal page. TODO(erights):
+ * upgrade the ecmascript WeakMap proposal page to explain this API
+ * change and present to EcmaScript committee for their approval.
+ *
+ * <p>The first difference between the emulation here and that in
+ * FF6.0a1 is the presence of non enumerable {@code get___, has___,
+ * set___, and delete___} methods on WeakMap instances to represent
+ * what would be the hidden internal properties of a primitive
+ * implementation. Whereas the FF6.0a1 WeakMap.prototype methods
+ * require their {@code this} to be a genuine WeakMap instance (i.e.,
+ * an object of {@code [[Class]]} "WeakMap}), since there is nothing
+ * unforgeable about the pseudo-internal method names used here,
+ * nothing prevents these emulated prototype methods from being
+ * applied to non-WeakMaps with pseudo-internal methods of the same
+ * names.
+ *
+ * <p>Another difference is that our emulated {@code
+ * WeakMap.prototype} is not itself a WeakMap. A problem with the
+ * current FF6.0a1 API is that WeakMap.prototype is itself a WeakMap
+ * providing ambient mutability and an ambient communications
+ * channel. Thus, if a WeakMap is already present and has this
+ * problem, repairES5.js wraps it in a safe wrappper in order to
+ * prevent access to this channel. (See
+ * PATCH_MUTABLE_FROZEN_WEAKMAP_PROTO in repairES5.js).
+ */
+
+/**
+ * If this is a full <a href=
+ * "http://code.google.com/p/es-lab/wiki/SecureableES5"
+ * >secureable ES5</a> platform and the ES-Harmony {@code WeakMap} is
+ * absent, install an approximate emulation.
+ *
+ * <p>If WeakMap is present but cannot store some objects, use our approximate
+ * emulation as a wrapper.
+ *
+ * <p>If this is almost a secureable ES5 platform, then WeakMap.js
+ * should be run after repairES5.js.
+ *
+ * <p>See {@code WeakMap} for documentation of the garbage collection
+ * properties of this WeakMap emulation.
+ */
+(function WeakMapModule() {
+  "use strict";
+
+  if (typeof ses !== 'undefined' && ses.ok && !ses.ok()) {
+    // already too broken, so give up
+    return;
+  }
+
+  /**
+   * In some cases (current Firefox), we must make a choice betweeen a
+   * WeakMap which is capable of using all varieties of host objects as
+   * keys and one which is capable of safely using proxies as keys. See
+   * comments below about HostWeakMap and DoubleWeakMap for details.
+   *
+   * This function (which is a global, not exposed to guests) marks a
+   * WeakMap as permitted to do what is necessary to index all host
+   * objects, at the cost of making it unsafe for proxies.
+   *
+   * Do not apply this function to anything which is not a genuine
+   * fresh WeakMap.
+   */
+  function weakMapPermitHostObjects(map) {
+    // identity of function used as a secret -- good enough and cheap
+    if (map.permitHostObjects___) {
+      map.permitHostObjects___(weakMapPermitHostObjects);
+    }
+  }
+  if (typeof ses !== 'undefined') {
+    ses.weakMapPermitHostObjects = weakMapPermitHostObjects;
+  }
+
+  // IE 11 has no Proxy but has a broken WeakMap such that we need to patch
+  // it using DoubleWeakMap; this flag tells DoubleWeakMap so.
+  var doubleWeakMapCheckSilentFailure = false;
+
+  // Check if there is already a good-enough WeakMap implementation, and if so
+  // exit without replacing it.
+  if (typeof WeakMap === 'function') {
+    var HostWeakMap = WeakMap;
+    // There is a WeakMap -- is it good enough?
+    if (typeof navigator !== 'undefined' &&
+        /Firefox/.test(navigator.userAgent)) {
+      // We're now *assuming not*, because as of this writing (2013-05-06)
+      // Firefox's WeakMaps have a miscellany of objects they won't accept, and
+      // we don't want to make an exhaustive list, and testing for just one
+      // will be a problem if that one is fixed alone (as they did for Event).
+
+      // If there is a platform that we *can* reliably test on, here's how to
+      // do it:
+      //  var problematic = ... ;
+      //  var testHostMap = new HostWeakMap();
+      //  try {
+      //    testHostMap.set(problematic, 1);  // Firefox 20 will throw here
+      //    if (testHostMap.get(problematic) === 1) {
+      //      return;
+      //    }
+      //  } catch (e) {}
+
+    } else {
+      // IE 11 bug: WeakMaps silently fail to store frozen objects.
+      var testMap = new HostWeakMap();
+      var testObject = Object.freeze({});
+      testMap.set(testObject, 1);
+      if (testMap.get(testObject) !== 1) {
+        doubleWeakMapCheckSilentFailure = true;
+        // Fall through to installing our WeakMap.
+      } else {
+        module.exports = WeakMap;
+        return;
+      }
+    }
+  }
+
+  var hop = Object.prototype.hasOwnProperty;
+  var gopn = Object.getOwnPropertyNames;
+  var defProp = Object.defineProperty;
+  var isExtensible = Object.isExtensible;
+
+  /**
+   * Security depends on HIDDEN_NAME being both <i>unguessable</i> and
+   * <i>undiscoverable</i> by untrusted code.
+   *
+   * <p>Given the known weaknesses of Math.random() on existing
+   * browsers, it does not generate unguessability we can be confident
+   * of.
+   *
+   * <p>It is the monkey patching logic in this file that is intended
+   * to ensure undiscoverability. The basic idea is that there are
+   * three fundamental means of discovering properties of an object:
+   * The for/in loop, Object.keys(), and Object.getOwnPropertyNames(),
+   * as well as some proposed ES6 extensions that appear on our
+   * whitelist. The first two only discover enumerable properties, and
+   * we only use HIDDEN_NAME to name a non-enumerable property, so the
+   * only remaining threat should be getOwnPropertyNames and some
+   * proposed ES6 extensions that appear on our whitelist. We monkey
+   * patch them to remove HIDDEN_NAME from the list of properties they
+   * returns.
+   *
+   * <p>TODO(erights): On a platform with built-in Proxies, proxies
+   * could be used to trap and thereby discover the HIDDEN_NAME, so we
+   * need to monkey patch Proxy.create, Proxy.createFunction, etc, in
+   * order to wrap the provided handler with the real handler which
+   * filters out all traps using HIDDEN_NAME.
+   *
+   * <p>TODO(erights): Revisit Mike Stay's suggestion that we use an
+   * encapsulated function at a not-necessarily-secret name, which
+   * uses the Stiegler shared-state rights amplification pattern to
+   * reveal the associated value only to the WeakMap in which this key
+   * is associated with that value. Since only the key retains the
+   * function, the function can also remember the key without causing
+   * leakage of the key, so this doesn't violate our general gc
+   * goals. In addition, because the name need not be a guarded
+   * secret, we could efficiently handle cross-frame frozen keys.
+   */
+  var HIDDEN_NAME_PREFIX = 'weakmap:';
+  var HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'ident:' + Math.random() + '___';
+
+  if (typeof crypto !== 'undefined' &&
+      typeof crypto.getRandomValues === 'function' &&
+      typeof ArrayBuffer === 'function' &&
+      typeof Uint8Array === 'function') {
+    var ab = new ArrayBuffer(25);
+    var u8s = new Uint8Array(ab);
+    crypto.getRandomValues(u8s);
+    HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'rand:' +
+      Array.prototype.map.call(u8s, function(u8) {
+        return (u8 % 36).toString(36);
+      }).join('') + '___';
+  }
+
+  function isNotHiddenName(name) {
+    return !(
+        name.substr(0, HIDDEN_NAME_PREFIX.length) == HIDDEN_NAME_PREFIX &&
+        name.substr(name.length - 3) === '___');
+  }
+
+  /**
+   * Monkey patch getOwnPropertyNames to avoid revealing the
+   * HIDDEN_NAME.
+   *
+   * <p>The ES5.1 spec requires each name to appear only once, but as
+   * of this writing, this requirement is controversial for ES6, so we
+   * made this code robust against this case. If the resulting extra
+   * search turns out to be expensive, we can probably relax this once
+   * ES6 is adequately supported on all major browsers, iff no browser
+   * versions we support at that time have relaxed this constraint
+   * without providing built-in ES6 WeakMaps.
+   */
+  defProp(Object, 'getOwnPropertyNames', {
+    value: function fakeGetOwnPropertyNames(obj) {
+      return gopn(obj).filter(isNotHiddenName);
+    }
+  });
+
+  /**
+   * getPropertyNames is not in ES5 but it is proposed for ES6 and
+   * does appear in our whitelist, so we need to clean it too.
+   */
+  if ('getPropertyNames' in Object) {
+    var originalGetPropertyNames = Object.getPropertyNames;
+    defProp(Object, 'getPropertyNames', {
+      value: function fakeGetPropertyNames(obj) {
+        return originalGetPropertyNames(obj).filter(isNotHiddenName);
+      }
+    });
+  }
+
+  /**
+   * <p>To treat objects as identity-keys with reasonable efficiency
+   * on ES5 by itself (i.e., without any object-keyed collections), we
+   * need to add a hidden property to such key objects when we
+   * can. This raises several issues:
+   * <ul>
+   * <li>Arranging to add this property to objects before we lose the
+   *     chance, and
+   * <li>Hiding the existence of this new property from most
+   *     JavaScript code.
+   * <li>Preventing <i>certification theft</i>, where one object is
+   *     created falsely claiming to be the key of an association
+   *     actually keyed by another object.
+   * <li>Preventing <i>value theft</i>, where untrusted code with
+   *     access to a key object but not a weak map nevertheless
+   *     obtains access to the value associated with that key in that
+   *     weak map.
+   * </ul>
+   * We do so by
+   * <ul>
+   * <li>Making the name of the hidden property unguessable, so "[]"
+   *     indexing, which we cannot intercept, cannot be used to access
+   *     a property without knowing the name.
+   * <li>Making the hidden property non-enumerable, so we need not
+   *     worry about for-in loops or {@code Object.keys},
+   * <li>monkey patching those reflective methods that would
+   *     prevent extensions, to add this hidden property first,
+   * <li>monkey patching those methods that would reveal this
+   *     hidden property.
+   * </ul>
+   * Unfortunately, because of same-origin iframes, we cannot reliably
+   * add this hidden property before an object becomes
+   * non-extensible. Instead, if we encounter a non-extensible object
+   * without a hidden record that we can detect (whether or not it has
+   * a hidden record stored under a name secret to us), then we just
+   * use the key object itself to represent its identity in a brute
+   * force leaky map stored in the weak map, losing all the advantages
+   * of weakness for these.
+   */
+  function getHiddenRecord(key) {
+    if (key !== Object(key)) {
+      throw new TypeError('Not an object: ' + key);
+    }
+    var hiddenRecord = key[HIDDEN_NAME];
+    if (hiddenRecord && hiddenRecord.key === key) { return hiddenRecord; }
+    if (!isExtensible(key)) {
+      // Weak map must brute force, as explained in doc-comment above.
+      return void 0;
+    }
+
+    // The hiddenRecord and the key point directly at each other, via
+    // the "key" and HIDDEN_NAME properties respectively. The key
+    // field is for quickly verifying that this hidden record is an
+    // own property, not a hidden record from up the prototype chain.
+    //
+    // NOTE: Because this WeakMap emulation is meant only for systems like
+    // SES where Object.prototype is frozen without any numeric
+    // properties, it is ok to use an object literal for the hiddenRecord.
+    // This has two advantages:
+    // * It is much faster in a performance critical place
+    // * It avoids relying on Object.create(null), which had been
+    //   problematic on Chrome 28.0.1480.0. See
+    //   https://code.google.com/p/google-caja/issues/detail?id=1687
+    hiddenRecord = { key: key };
+
+    // When using this WeakMap emulation on platforms where
+    // Object.prototype might not be frozen and Object.create(null) is
+    // reliable, use the following two commented out lines instead.
+    // hiddenRecord = Object.create(null);
+    // hiddenRecord.key = key;
+
+    // Please contact us if you need this to work on platforms where
+    // Object.prototype might not be frozen and
+    // Object.create(null) might not be reliable.
+
+    try {
+      defProp(key, HIDDEN_NAME, {
+        value: hiddenRecord,
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      return hiddenRecord;
+    } catch (error) {
+      // Under some circumstances, isExtensible seems to misreport whether
+      // the HIDDEN_NAME can be defined.
+      // The circumstances have not been isolated, but at least affect
+      // Node.js v0.10.26 on TravisCI / Linux, but not the same version of
+      // Node.js on OS X.
+      return void 0;
+    }
+  }
+
+  /**
+   * Monkey patch operations that would make their argument
+   * non-extensible.
+   *
+   * <p>The monkey patched versions throw a TypeError if their
+   * argument is not an object, so it should only be done to functions
+   * that should throw a TypeError anyway if their argument is not an
+   * object.
+   */
+  (function(){
+    var oldFreeze = Object.freeze;
+    defProp(Object, 'freeze', {
+      value: function identifyingFreeze(obj) {
+        getHiddenRecord(obj);
+        return oldFreeze(obj);
+      }
+    });
+    var oldSeal = Object.seal;
+    defProp(Object, 'seal', {
+      value: function identifyingSeal(obj) {
+        getHiddenRecord(obj);
+        return oldSeal(obj);
+      }
+    });
+    var oldPreventExtensions = Object.preventExtensions;
+    defProp(Object, 'preventExtensions', {
+      value: function identifyingPreventExtensions(obj) {
+        getHiddenRecord(obj);
+        return oldPreventExtensions(obj);
+      }
+    });
+  })();
+
+  function constFunc(func) {
+    func.prototype = null;
+    return Object.freeze(func);
+  }
+
+  var calledAsFunctionWarningDone = false;
+  function calledAsFunctionWarning() {
+    // Future ES6 WeakMap is currently (2013-09-10) expected to reject WeakMap()
+    // but we used to permit it and do it ourselves, so warn only.
+    if (!calledAsFunctionWarningDone && typeof console !== 'undefined') {
+      calledAsFunctionWarningDone = true;
+      console.warn('WeakMap should be invoked as new WeakMap(), not ' +
+          'WeakMap(). This will be an error in the future.');
+    }
+  }
+
+  var nextId = 0;
+
+  var OurWeakMap = function() {
+    if (!(this instanceof OurWeakMap)) {  // approximate test for new ...()
+      calledAsFunctionWarning();
+    }
+
+    // We are currently (12/25/2012) never encountering any prematurely
+    // non-extensible keys.
+    var keys = []; // brute force for prematurely non-extensible keys.
+    var values = []; // brute force for corresponding values.
+    var id = nextId++;
+
+    function get___(key, opt_default) {
+      var index;
+      var hiddenRecord = getHiddenRecord(key);
+      if (hiddenRecord) {
+        return id in hiddenRecord ? hiddenRecord[id] : opt_default;
+      } else {
+        index = keys.indexOf(key);
+        return index >= 0 ? values[index] : opt_default;
+      }
+    }
+
+    function has___(key) {
+      var hiddenRecord = getHiddenRecord(key);
+      if (hiddenRecord) {
+        return id in hiddenRecord;
+      } else {
+        return keys.indexOf(key) >= 0;
+      }
+    }
+
+    function set___(key, value) {
+      var index;
+      var hiddenRecord = getHiddenRecord(key);
+      if (hiddenRecord) {
+        hiddenRecord[id] = value;
+      } else {
+        index = keys.indexOf(key);
+        if (index >= 0) {
+          values[index] = value;
+        } else {
+          // Since some browsers preemptively terminate slow turns but
+          // then continue computing with presumably corrupted heap
+          // state, we here defensively get keys.length first and then
+          // use it to update both the values and keys arrays, keeping
+          // them in sync.
+          index = keys.length;
+          values[index] = value;
+          // If we crash here, values will be one longer than keys.
+          keys[index] = key;
+        }
+      }
+      return this;
+    }
+
+    function delete___(key) {
+      var hiddenRecord = getHiddenRecord(key);
+      var index, lastIndex;
+      if (hiddenRecord) {
+        return id in hiddenRecord && delete hiddenRecord[id];
+      } else {
+        index = keys.indexOf(key);
+        if (index < 0) {
+          return false;
+        }
+        // Since some browsers preemptively terminate slow turns but
+        // then continue computing with potentially corrupted heap
+        // state, we here defensively get keys.length first and then use
+        // it to update both the keys and the values array, keeping
+        // them in sync. We update the two with an order of assignments,
+        // such that any prefix of these assignments will preserve the
+        // key/value correspondence, either before or after the delete.
+        // Note that this needs to work correctly when index === lastIndex.
+        lastIndex = keys.length - 1;
+        keys[index] = void 0;
+        // If we crash here, there's a void 0 in the keys array, but
+        // no operation will cause a "keys.indexOf(void 0)", since
+        // getHiddenRecord(void 0) will always throw an error first.
+        values[index] = values[lastIndex];
+        // If we crash here, values[index] cannot be found here,
+        // because keys[index] is void 0.
+        keys[index] = keys[lastIndex];
+        // If index === lastIndex and we crash here, then keys[index]
+        // is still void 0, since the aliasing killed the previous key.
+        keys.length = lastIndex;
+        // If we crash here, keys will be one shorter than values.
+        values.length = lastIndex;
+        return true;
+      }
+    }
+
+    return Object.create(OurWeakMap.prototype, {
+      get___:    { value: constFunc(get___) },
+      has___:    { value: constFunc(has___) },
+      set___:    { value: constFunc(set___) },
+      delete___: { value: constFunc(delete___) }
+    });
+  };
+
+  OurWeakMap.prototype = Object.create(Object.prototype, {
+    get: {
+      /**
+       * Return the value most recently associated with key, or
+       * opt_default if none.
+       */
+      value: function get(key, opt_default) {
+        return this.get___(key, opt_default);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    has: {
+      /**
+       * Is there a value associated with key in this WeakMap?
+       */
+      value: function has(key) {
+        return this.has___(key);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    set: {
+      /**
+       * Associate value with key in this WeakMap, overwriting any
+       * previous association if present.
+       */
+      value: function set(key, value) {
+        return this.set___(key, value);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    'delete': {
+      /**
+       * Remove any association for key in this WeakMap, returning
+       * whether there was one.
+       *
+       * <p>Note that the boolean return here does not work like the
+       * {@code delete} operator. The {@code delete} operator returns
+       * whether the deletion succeeds at bringing about a state in
+       * which the deleted property is absent. The {@code delete}
+       * operator therefore returns true if the property was already
+       * absent, whereas this {@code delete} method returns false if
+       * the association was already absent.
+       */
+      value: function remove(key) {
+        return this.delete___(key);
+      },
+      writable: true,
+      configurable: true
+    }
+  });
+
+  if (typeof HostWeakMap === 'function') {
+    (function() {
+      // If we got here, then the platform has a WeakMap but we are concerned
+      // that it may refuse to store some key types. Therefore, make a map
+      // implementation which makes use of both as possible.
+
+      // In this mode we are always using double maps, so we are not proxy-safe.
+      // This combination does not occur in any known browser, but we had best
+      // be safe.
+      if (doubleWeakMapCheckSilentFailure && typeof Proxy !== 'undefined') {
+        Proxy = undefined;
+      }
+
+      function DoubleWeakMap() {
+        if (!(this instanceof OurWeakMap)) {  // approximate test for new ...()
+          calledAsFunctionWarning();
+        }
+
+        // Preferable, truly weak map.
+        var hmap = new HostWeakMap();
+
+        // Our hidden-property-based pseudo-weak-map. Lazily initialized in the
+        // 'set' implementation; thus we can avoid performing extra lookups if
+        // we know all entries actually stored are entered in 'hmap'.
+        var omap = undefined;
+
+        // Hidden-property maps are not compatible with proxies because proxies
+        // can observe the hidden name and either accidentally expose it or fail
+        // to allow the hidden property to be set. Therefore, we do not allow
+        // arbitrary WeakMaps to switch to using hidden properties, but only
+        // those which need the ability, and unprivileged code is not allowed
+        // to set the flag.
+        //
+        // (Except in doubleWeakMapCheckSilentFailure mode in which case we
+        // disable proxies.)
+        var enableSwitching = false;
+
+        function dget(key, opt_default) {
+          if (omap) {
+            return hmap.has(key) ? hmap.get(key)
+                : omap.get___(key, opt_default);
+          } else {
+            return hmap.get(key, opt_default);
+          }
+        }
+
+        function dhas(key) {
+          return hmap.has(key) || (omap ? omap.has___(key) : false);
+        }
+
+        var dset;
+        if (doubleWeakMapCheckSilentFailure) {
+          dset = function(key, value) {
+            hmap.set(key, value);
+            if (!hmap.has(key)) {
+              if (!omap) { omap = new OurWeakMap(); }
+              omap.set(key, value);
+            }
+            return this;
+          };
+        } else {
+          dset = function(key, value) {
+            if (enableSwitching) {
+              try {
+                hmap.set(key, value);
+              } catch (e) {
+                if (!omap) { omap = new OurWeakMap(); }
+                omap.set___(key, value);
+              }
+            } else {
+              hmap.set(key, value);
+            }
+            return this;
+          };
+        }
+
+        function ddelete(key) {
+          var result = !!hmap['delete'](key);
+          if (omap) { return omap.delete___(key) || result; }
+          return result;
+        }
+
+        return Object.create(OurWeakMap.prototype, {
+          get___:    { value: constFunc(dget) },
+          has___:    { value: constFunc(dhas) },
+          set___:    { value: constFunc(dset) },
+          delete___: { value: constFunc(ddelete) },
+          permitHostObjects___: { value: constFunc(function(token) {
+            if (token === weakMapPermitHostObjects) {
+              enableSwitching = true;
+            } else {
+              throw new Error('bogus call to permitHostObjects___');
+            }
+          })}
+        });
+      }
+      DoubleWeakMap.prototype = OurWeakMap.prototype;
+      module.exports = DoubleWeakMap;
+
+      // define .constructor to hide OurWeakMap ctor
+      Object.defineProperty(WeakMap.prototype, 'constructor', {
+        value: WeakMap,
+        enumerable: false,  // as default .constructor is
+        configurable: true,
+        writable: true
+      });
+    })();
+  } else {
+    // There is no host WeakMap, so we must use the emulation.
+
+    // Emulated WeakMaps are incompatible with native proxies (because proxies
+    // can observe the hidden name), so we must disable Proxy usage (in
+    // ArrayLike and Domado, currently).
+    if (typeof Proxy !== 'undefined') {
+      Proxy = undefined;
+    }
+
+    module.exports = OurWeakMap;
+  }
+})();
+
+},{}],17:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var List = require("./list");
+var FastSet = require("./fast-set");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+module.exports = Set;
+
+function Set(values, equals, hash, getDefault) {
+    if (!(this instanceof Set)) {
+        return new Set(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    // a list of values in insertion order, used for all operations that depend
+    // on iterating in insertion order
+    this.order = new this.Order(undefined, equals);
+    // a set of nodes from the order list, indexed by the corresponding value,
+    // used for all operations that need to quickly seek  value in the list
+    this.store = new this.Store(
+        undefined,
+        function (a, b) {
+            return equals(a.value, b.value);
+        },
+        function (node) {
+            return hash(node.value);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+Set.Set = Set; // hack so require("set").Set will work in MontageJS
+
+Object.addEach(Set.prototype, GenericCollection.prototype);
+Object.addEach(Set.prototype, GenericSet.prototype);
+Object.addEach(Set.prototype, PropertyChanges.prototype);
+Object.addEach(Set.prototype, RangeChanges.prototype);
+
+Set.prototype.Order = List;
+Set.prototype.Store = FastSet;
+
+Set.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.contentEquals, this.contentHash, this.getDefault);
+};
+
+Set.prototype.has = function (value) {
+    var node = new this.order.Node(value);
+    return this.store.has(node);
+};
+
+Set.prototype.get = function (value, equals) {
+    if (equals) {
+        throw new Error("Set#get does not support second argument: equals");
+    }
+    var node = new this.order.Node(value);
+    node = this.store.get(node);
+    if (node) {
+        return node.value;
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+Set.prototype.add = function (value) {
+    var node = new this.order.Node(value);
+    if (!this.store.has(node)) {
+        var index = this.length;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([value], [], index);
+        }
+        this.order.add(value);
+        node = this.order.head.prev;
+        this.store.add(node);
+        this.length++;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([value], [], index);
+        }
+        return true;
+    }
+    return false;
+};
+
+Set.prototype["delete"] = function (value, equals) {
+    if (equals) {
+        throw new Error("Set#delete does not support second argument: equals");
+    }
+    var node = new this.order.Node(value);
+    if (this.store.has(node)) {
+        node = this.store.get(node);
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([], [value], node.index);
+        }
+        this.store["delete"](node); // removes from the set
+        this.order.splice(node, 1); // removes the node from the list
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([], [value], node.index);
+        }
+        return true;
+    }
+    return false;
+};
+
+Set.prototype.pop = function () {
+    if (this.length) {
+        var result = this.order.head.prev.value;
+        this["delete"](result);
+        return result;
+    }
+};
+
+Set.prototype.shift = function () {
+    if (this.length) {
+        var result = this.order.head.next.value;
+        this["delete"](result);
+        return result;
+    }
+};
+
+Set.prototype.one = function () {
+    if (this.length > 0) {
+        return this.store.one().value;
+    }
+};
+
+Set.prototype.clear = function () {
+    var clearing;
+    if (this.dispatchesRangeChanges) {
+        clearing = this.toArray();
+        this.dispatchBeforeRangeChange([], clearing, 0);
+    }
+    this.store.clear();
+    this.order.clear();
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], clearing, 0);
+    }
+};
+
+Set.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var list = this.order;
+    var index = 0;
+    return list.reduce(function (basis, value) {
+        return callback.call(thisp, basis, value, index++, this);
+    }, basis, this);
+};
+
+Set.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var list = this.order;
+    var index = this.length - 1;
+    return list.reduceRight(function (basis, value) {
+        return callback.call(thisp, basis, value, index--, this);
+    }, basis, this);
+};
+
+Set.prototype.iterate = function () {
+    return this.order.iterate();
+};
+
+Set.prototype.log = function () {
+    var set = this.store;
+    return set.log.apply(set, arguments);
+};
+
+Set.prototype.makeObservable = function () {
+    this.order.makeObservable();
+};
+
+
+},{"./fast-set":7,"./generic-collection":8,"./generic-set":11,"./list":12,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22}],18:[function(require,module,exports){
+"use strict";
+
+/*
+    Based in part on extras from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+var Function = require("./shim-function");
+var GenericCollection = require("./generic-collection");
+var GenericOrder = require("./generic-order");
+var WeakMap = require("weak-map");
+
+module.exports = Array;
+
+var array_splice = Array.prototype.splice;
+var array_slice = Array.prototype.slice;
+
+Array.empty = [];
+
+if (Object.freeze) {
+    Object.freeze(Array.empty);
+}
+
+Array.from = function (values) {
+    var array = [];
+    array.addEach(values);
+    return array;
+};
+
+Array.unzip = function (table) {
+    var transpose = [];
+    var length = Infinity;
+    // compute shortest row
+    for (var i = 0; i < table.length; i++) {
+        var row = table[i];
+        table[i] = row.toArray();
+        if (row.length < length) {
+            length = row.length;
+        }
+    }
+    for (var i = 0; i < table.length; i++) {
+        var row = table[i];
+        for (var j = 0; j < row.length; j++) {
+            if (j < length && j in row) {
+                transpose[j] = transpose[j] || [];
+                transpose[j][i] = row[j];
+            }
+        }
+    }
+    return transpose;
+};
+
+function define(key, value) {
+    Object.defineProperty(Array.prototype, key, {
+        value: value,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+}
+
+define("addEach", GenericCollection.prototype.addEach);
+define("deleteEach", GenericCollection.prototype.deleteEach);
+define("toArray", GenericCollection.prototype.toArray);
+define("toObject", GenericCollection.prototype.toObject);
+define("all", GenericCollection.prototype.all);
+define("any", GenericCollection.prototype.any);
+define("min", GenericCollection.prototype.min);
+define("max", GenericCollection.prototype.max);
+define("sum", GenericCollection.prototype.sum);
+define("average", GenericCollection.prototype.average);
+define("only", GenericCollection.prototype.only);
+define("flatten", GenericCollection.prototype.flatten);
+define("zip", GenericCollection.prototype.zip);
+define("enumerate", GenericCollection.prototype.enumerate);
+define("group", GenericCollection.prototype.group);
+define("sorted", GenericCollection.prototype.sorted);
+define("reversed", GenericCollection.prototype.reversed);
+
+define("constructClone", function (values) {
+    var clone = new this.constructor();
+    clone.addEach(values);
+    return clone;
+});
+
+define("has", function (value, equals) {
+    return this.find(value, equals) !== -1;
+});
+
+define("get", function (index, defaultValue) {
+    if (+index !== index)
+        throw new Error("Indicies must be numbers");
+    if (!index in this) {
+        return defaultValue;
+    } else {
+        return this[index];
+    }
+});
+
+define("set", function (index, value) {
+    this[index] = value;
+    return true;
+});
+
+define("add", function (value) {
+    this.push(value);
+    return true;
+});
+
+define("delete", function (value, equals) {
+    var index = this.find(value, equals);
+    if (index !== -1) {
+        this.splice(index, 1);
+        return true;
+    }
+    return false;
+});
+
+define("deleteAll", function (value, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+    var count = 0;
+    for (var index = 0; index < this.length;) {
+        if (equals(value, this[index])) {
+            this.swap(index, 1);
+            count++;
+        } else {
+            index++;
+        }
+    }
+    return count;
+});
+
+define("find", function (value, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+    for (var index = 0; index < this.length; index++) {
+        if (index in this && equals(value, this[index])) {
+            return index;
+        }
+    }
+    return -1;
+});
+
+define("findLast", function (value, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+    var index = this.length;
+    do {
+        index--;
+        if (index in this && equals(this[index], value)) {
+            return index;
+        }
+    } while (index > 0);
+    return -1;
+});
+
+define("swap", function (start, length, plus) {
+    var args, plusLength, i, j, returnValue;
+    if (start > this.length) {
+        this.length = start;
+    }
+    if (typeof plus !== "undefined") {
+        args = [start, length];
+        if (!Array.isArray(plus)) {
+            plus = array_slice.call(plus);
+        }
+        i = 0;
+        plusLength = plus.length;
+        // 1000 is a magic number, presumed to be smaller than the remaining
+        // stack length. For swaps this small, we take the fast path and just
+        // use the underlying Array splice. We could measure the exact size of
+        // the remaining stack using a try/catch around an unbounded recursive
+        // function, but this would defeat the purpose of short-circuiting in
+        // the common case.
+        if (plusLength < 1000) {
+            for (i; i < plusLength; i++) {
+                args[i+2] = plus[i];
+            }
+            return array_splice.apply(this, args);
+        } else {
+            // Avoid maximum call stack error.
+            // First delete the desired entries.
+            returnValue = array_splice.apply(this, args);
+            // Second batch in 1000s.
+            for (i; i < plusLength;) {
+                args = [start+i, 0];
+                for (j = 2; j < 1002 && i < plusLength; j++, i++) {
+                    args[j] = plus[i];
+                }
+                array_splice.apply(this, args);
+            }
+            return returnValue;
+        }
+    // using call rather than apply to cut down on transient objects
+    } else if (typeof length !== "undefined") {
+        return array_splice.call(this, start, length);
+    }  else if (typeof start !== "undefined") {
+        return array_splice.call(this, start);
+    } else {
+        return [];
+    }
+});
+
+define("peek", function () {
+    return this[0];
+});
+
+define("poke", function (value) {
+    if (this.length > 0) {
+        this[0] = value;
+    }
+});
+
+define("peekBack", function () {
+    if (this.length > 0) {
+        return this[this.length - 1];
+    }
+});
+
+define("pokeBack", function (value) {
+    if (this.length > 0) {
+        this[this.length - 1] = value;
+    }
+});
+
+define("one", function () {
+    for (var i in this) {
+        if (Object.owns(this, i)) {
+            return this[i];
+        }
+    }
+});
+
+if (!Array.prototype.clear) {
+    define("clear", function () {
+        this.length = 0;
+        return this;
+    });
+}
+
+define("compare", function (that, compare) {
+    compare = compare || Object.compare;
+    var i;
+    var length;
+    var lhs;
+    var rhs;
+    var relative;
+
+    if (this === that) {
+        return 0;
+    }
+
+    if (!that || !Array.isArray(that)) {
+        return GenericOrder.prototype.compare.call(this, that, compare);
+    }
+
+    length = Math.min(this.length, that.length);
+
+    for (i = 0; i < length; i++) {
+        if (i in this) {
+            if (!(i in that)) {
+                return -1;
+            } else {
+                lhs = this[i];
+                rhs = that[i];
+                relative = compare(lhs, rhs);
+                if (relative) {
+                    return relative;
+                }
+            }
+        } else if (i in that) {
+            return 1;
+        }
+    }
+
+    return this.length - that.length;
+});
+
+define("equals", function (that, equals) {
+    equals = equals || Object.equals;
+    var i = 0;
+    var length = this.length;
+    var left;
+    var right;
+
+    if (this === that) {
+        return true;
+    }
+    if (!that || !Array.isArray(that)) {
+        return GenericOrder.prototype.equals.call(this, that);
+    }
+
+    if (length !== that.length) {
+        return false;
+    } else {
+        for (; i < length; ++i) {
+            if (i in this) {
+                if (!(i in that)) {
+                    return false;
+                }
+                left = this[i];
+                right = that[i];
+                if (!equals(left, right)) {
+                    return false;
+                }
+            } else {
+                if (i in that) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+});
+
+define("clone", function (depth, memo) {
+    if (depth == null) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return this;
+    }
+    memo = memo || new WeakMap();
+    if (memo.has(this)) {
+        return memo.get(this);
+    }
+    var clone = new Array(this.length);
+    memo.set(this, clone);
+    for (var i in this) {
+        clone[i] = Object.clone(this[i], depth - 1, memo);
+    };
+    return clone;
+});
+
+define("iterate", function (start, end) {
+    return new ArrayIterator(this, start, end);
+});
+
+define("Iterator", ArrayIterator);
+
+function ArrayIterator(array, start, end) {
+    this.array = array;
+    this.start = start == null ? 0 : start;
+    this.end = end;
+};
+
+ArrayIterator.prototype.next = function () {
+    if (this.start === (this.end == null ? this.array.length : this.end)) {
+        throw StopIteration;
+    } else {
+        return this.array[this.start++];
+    }
+};
+
+
+},{"./generic-collection":8,"./generic-order":10,"./shim-function":19,"weak-map":16}],19:[function(require,module,exports){
+
+module.exports = Function;
+
+/**
+    A utility to reduce unnecessary allocations of <code>function () {}</code>
+    in its many colorful variations.  It does nothing and returns
+    <code>undefined</code> thus makes a suitable default in some circumstances.
+
+    @function external:Function.noop
+*/
+Function.noop = function () {
+};
+
+/**
+    A utility to reduce unnecessary allocations of <code>function (x) {return
+    x}</code> in its many colorful but ultimately wasteful parameter name
+    variations.
+
+    @function external:Function.identity
+    @param {Any} any value
+    @returns {Any} that value
+*/
+Function.identity = function (value) {
+    return value;
+};
+
+/**
+    A utility for creating a comparator function for a particular aspect of a
+    figurative class of objects.
+
+    @function external:Function.by
+    @param {Function} relation A function that accepts a value and returns a
+    corresponding value to use as a representative when sorting that object.
+    @param {Function} compare an alternate comparator for comparing the
+    represented values.  The default is <code>Object.compare</code>, which
+    does a deep, type-sensitive, polymorphic comparison.
+    @returns {Function} a comparator that has been annotated with
+    <code>by</code> and <code>compare</code> properties so
+    <code>sorted</code> can perform a transform that reduces the need to call
+    <code>by</code> on each sorted object to just once.
+ */
+Function.by = function (by , compare) {
+    compare = compare || Object.compare;
+    by = by || Function.identity;
+    var compareBy = function (a, b) {
+        return compare(by(a), by(b));
+    };
+    compareBy.compare = compare;
+    compareBy.by = by;
+    return compareBy;
+};
+
+// TODO document
+Function.get = function (key) {
+    return function (object) {
+        return Object.get(object, key);
+    };
+};
+
+
+},{}],20:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+
+module.exports = Object;
+
+/*
+    Based in part on extras from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/**
+    Defines extensions to intrinsic <code>Object</code>.
+    @see [Object class]{@link external:Object}
+*/
+
+/**
+    A utility object to avoid unnecessary allocations of an empty object
+    <code>{}</code>.  This object is frozen so it is safe to share.
+
+    @object external:Object.empty
+*/
+Object.empty = Object.freeze(Object.create(null));
+
+/**
+    Returns whether the given value is an object, as opposed to a value.
+    Unboxed numbers, strings, true, false, undefined, and null are not
+    objects.  Arrays are objects.
+
+    @function external:Object.isObject
+    @param {Any} value
+    @returns {Boolean} whether the given value is an object
+*/
+Object.isObject = function (object) {
+    return Object(object) === object;
+};
+
+/**
+    Returns the value of an any value, particularly objects that
+    implement <code>valueOf</code>.
+
+    <p>Note that, unlike the precedent of methods like
+    <code>Object.equals</code> and <code>Object.compare</code> would suggest,
+    this method is named <code>Object.getValueOf</code> instead of
+    <code>valueOf</code>.  This is a delicate issue, but the basis of this
+    decision is that the JavaScript runtime would be far more likely to
+    accidentally call this method with no arguments, assuming that it would
+    return the value of <code>Object</code> itself in various situations,
+    whereas <code>Object.equals(Object, null)</code> protects against this case
+    by noting that <code>Object</code> owns the <code>equals</code> property
+    and therefore does not delegate to it.
+
+    @function external:Object.getValueOf
+    @param {Any} value a value or object wrapping a value
+    @returns {Any} the primitive value of that object, if one exists, or passes
+    the value through
+*/
+Object.getValueOf = function (value) {
+    if (value && typeof value.valueOf === "function") {
+        value = value.valueOf();
+    }
+    return value;
+};
+
+var hashMap = new WeakMap();
+Object.hash = function (object) {
+    if (object && typeof object.hash === "function") {
+        return "" + object.hash();
+    } else if (Object(object) === object) {
+        if (!hashMap.has(object)) {
+            hashMap.set(object, Math.random().toString(36).slice(2));
+        }
+        return hashMap.get(object);
+    } else {
+        return "" + object;
+    }
+};
+
+/**
+    A shorthand for <code>Object.prototype.hasOwnProperty.call(object,
+    key)</code>.  Returns whether the object owns a property for the given key.
+    It does not consult the prototype chain and works for any string (including
+    "hasOwnProperty") except "__proto__".
+
+    @function external:Object.owns
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object owns a property wfor the given key.
+*/
+var owns = Object.prototype.hasOwnProperty;
+Object.owns = function (object, key) {
+    return owns.call(object, key);
+};
+
+/**
+    A utility that is like Object.owns but is also useful for finding
+    properties on the prototype chain, provided that they do not refer to
+    methods on the Object prototype.  Works for all strings except "__proto__".
+
+    <p>Alternately, you could use the "in" operator as long as the object
+    descends from "null" instead of the Object.prototype, as with
+    <code>Object.create(null)</code>.  However,
+    <code>Object.create(null)</code> only works in fully compliant EcmaScript 5
+    JavaScript engines and cannot be faithfully shimmed.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "has", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the instance.
+
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object, or any of its prototypes except
+    <code>Object.prototype</code>
+    @function external:Object.has
+*/
+Object.has = function (object, key) {
+    if (typeof object !== "object") {
+        throw new Error("Object.has can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "has"
+    if (object && typeof object.has === "function") {
+        return object.has(key);
+    // otherwise report whether the key is on the prototype chain,
+    // as long as it is not one of the methods on object.prototype
+    } else if (typeof key === "string") {
+        return key in object && object[key] !== Object.prototype[key];
+    } else {
+        throw new Error("Key must be a string for Object.has on plain objects");
+    }
+};
+
+/**
+    Gets the value for a corresponding key from an object.
+
+    <p>Uses Object.has to determine whether there is a corresponding value for
+    the given key.  As such, <code>Object.get</code> is capable of retriving
+    values from the prototype chain as long as they are not from the
+    <code>Object.prototype</code>.
+
+    <p>If there is no corresponding value, returns the given default, which may
+    be <code>undefined</code>.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "get", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the implementation.  For a `Map`,
+    for example, the key might be any object.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value a default to return, <code>undefined</code> if omitted
+    @returns {Any} value for key, or default value
+    @function external:Object.get
+*/
+Object.get = function (object, key, value) {
+    if (typeof object !== "object") {
+        throw new Error("Object.get can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "get"
+    if (object && typeof object.get === "function") {
+        return object.get(key, value);
+    } else if (Object.has(object, key)) {
+        return object[key];
+    } else {
+        return value;
+    }
+};
+
+/**
+    Sets the value for a given key on an object.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "set", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  As such,
+    the key domain varies by the object type.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value
+    @returns <code>undefined</code>
+    @function external:Object.set
+*/
+Object.set = function (object, key, value) {
+    if (object && typeof object.set === "function") {
+        object.set(key, value);
+    } else {
+        object[key] = value;
+    }
+};
+
+Object.addEach = function (target, source) {
+    if (!source) {
+    } else if (typeof source.forEach === "function" && !source.hasOwnProperty("forEach")) {
+        // copy map-alikes
+        if (source.isMap === true) {
+            source.forEach(function (value, key) {
+                target[key] = value;
+            });
+        // iterate key value pairs of other iterables
+        } else {
+            source.forEach(function (pair) {
+                target[pair[0]] = pair[1];
+            });
+        }
+    } else if (typeof source.length === "number") {
+        // arguments, strings
+        for (var index = 0; index < source.length; index++) {
+            target[index] = source[index];
+        }
+    } else {
+        // copy other objects as map-alikes
+        Object.keys(source).forEach(function (key) {
+            target[key] = source[key];
+        });
+    }
+    return target;
+};
+
+/**
+    Iterates over the owned properties of an object.
+
+    @function external:Object.forEach
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+*/
+Object.forEach = function (object, callback, thisp) {
+    Object.keys(object).forEach(function (key) {
+        callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Iterates over the owned properties of a map, constructing a new array of
+    mapped values.
+
+    @function external:Object.map
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+    @returns {Array} the respective values returned by the callback for each
+    item in the object.
+*/
+Object.map = function (object, callback, thisp) {
+    return Object.keys(object).map(function (key) {
+        return callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Returns the values for owned properties of an object.
+
+    @function external:Object.map
+    @param {Object} object
+    @returns {Array} the respective value for each owned property of the
+    object.
+*/
+Object.values = function (object) {
+    return Object.map(object, Function.identity);
+};
+
+// TODO inline document concat
+Object.concat = function () {
+    var object = {};
+    for (var i = 0; i < arguments.length; i++) {
+        Object.addEach(object, arguments[i]);
+    }
+    return object;
+};
+
+Object.from = Object.concat;
+
+/**
+    Returns whether two values are identical.  Any value is identical to itself
+    and only itself.  This is much more restictive than equivalence and subtly
+    different than strict equality, <code>===</code> because of edge cases
+    including negative zero and <code>NaN</code>.  Identity is useful for
+    resolving collisions among keys in a mapping where the domain is any value.
+    This method does not delgate to any method on an object and cannot be
+    overridden.
+    @see http://wiki.ecmascript.org/doku.php?id=harmony:egal
+    @param {Any} this
+    @param {Any} that
+    @returns {Boolean} whether this and that are identical
+    @function external:Object.is
+*/
+Object.is = function (x, y) {
+    if (x === y) {
+        // 0 === -0, but they are not identical
+        return x !== 0 || 1 / x === 1 / y;
+    }
+    // NaN !== NaN, but they are identical.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    return x !== x && y !== y;
+};
+
+/**
+    Performs a polymorphic, type-sensitive deep equivalence comparison of any
+    two values.
+
+    <p>As a basic principle, any value is equivalent to itself (as in
+    identity), any boxed version of itself (as a <code>new Number(10)</code> is
+    to 10), and any deep clone of itself.
+
+    <p>Equivalence has the following properties:
+
+    <ul>
+        <li><strong>polymorphic:</strong>
+            If the given object is an instance of a type that implements a
+            methods named "equals", this function defers to the method.  So,
+            this function can safely compare any values regardless of type,
+            including undefined, null, numbers, strings, any pair of objects
+            where either implements "equals", or object literals that may even
+            contain an "equals" key.
+        <li><strong>type-sensitive:</strong>
+            Incomparable types are not equal.  No object is equivalent to any
+            array.  No string is equal to any other number.
+        <li><strong>deep:</strong>
+            Collections with equivalent content are equivalent, recursively.
+        <li><strong>equivalence:</strong>
+            Identical values and objects are equivalent, but so are collections
+            that contain equivalent content.  Whether order is important varies
+            by type.  For Arrays and lists, order is important.  For Objects,
+            maps, and sets, order is not important.  Boxed objects are mutally
+            equivalent with their unboxed values, by virtue of the standard
+            <code>valueOf</code> method.
+    </ul>
+    @param this
+    @param that
+    @returns {Boolean} whether the values are deeply equivalent
+    @function external:Object.equals
+*/
+Object.equals = function (a, b, equals, memo) {
+    equals = equals || Object.equals;
+    // unbox objects, but do not confuse object literals
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    if (a === b)
+        return true;
+    if (Object.isObject(a)) {
+        memo = memo || new WeakMap();
+        if (memo.has(a)) {
+            return true;
+        }
+        memo.set(a, true);
+    }
+    if (Object.isObject(a) && typeof a.equals === "function") {
+        return a.equals(b, equals, memo);
+    }
+    // commutative
+    if (Object.isObject(b) && typeof b.equals === "function") {
+        return b.equals(a, equals, memo);
+    }
+    if (Object.isObject(a) && Object.isObject(b)) {
+        if (Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
+            for (var name in a) {
+                if (!equals(a[name], b[name], equals, memo)) {
+                    return false;
+                }
+            }
+            for (var name in b) {
+                if (!(name in a) || !equals(b[name], a[name], equals, memo)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    // NaN !== NaN, but they are equal.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    // We have established that a !== b, but if a !== a && b !== b, they are
+    // both NaN.
+    if (a !== a && b !== b)
+        return true;
+    if (!a || !b)
+        return a === b;
+    return false;
+};
+
+// Because a return value of 0 from a `compare` function  may mean either
+// "equals" or "is incomparable", `equals` cannot be defined in terms of
+// `compare`.  However, `compare` *can* be defined in terms of `equals` and
+// `lessThan`.  Again however, more often it would be desirable to implement
+// all of the comparison functions in terms of compare rather than the other
+// way around.
+
+/**
+    Determines the order in which any two objects should be sorted by returning
+    a number that has an analogous relationship to zero as the left value to
+    the right.  That is, if the left is "less than" the right, the returned
+    value will be "less than" zero, where "less than" may be any other
+    transitive relationship.
+
+    <p>Arrays are compared by the first diverging values, or by length.
+
+    <p>Any two values that are incomparable return zero.  As such,
+    <code>equals</code> should not be implemented with <code>compare</code>
+    since incomparability is indistinguishable from equality.
+
+    <p>Sorts strings lexicographically.  This is not suitable for any
+    particular international setting.  Different locales sort their phone books
+    in very different ways, particularly regarding diacritics and ligatures.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "compare", this function defers to the instance.  The method does not
+    need to be an owned property to distinguish it from an object literal since
+    object literals are incomparable.  Unlike <code>Object</code> however,
+    <code>Array</code> implements <code>compare</code>.
+
+    @param {Any} left
+    @param {Any} right
+    @returns {Number} a value having the same transitive relationship to zero
+    as the left and right values.
+    @function external:Object.compare
+*/
+Object.compare = function (a, b) {
+    // unbox objects, but do not confuse object literals
+    // mercifully handles the Date case
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    if (a === b)
+        return 0;
+    var aType = typeof a;
+    var bType = typeof b;
+    if (aType === "number" && bType === "number")
+        return a - b;
+    if (aType === "string" && bType === "string")
+        return a < b ? -Infinity : Infinity;
+        // the possibility of equality elimiated above
+    if (a && typeof a.compare === "function")
+        return a.compare(b);
+    // not commutative, the relationship is reversed
+    if (b && typeof b.compare === "function")
+        return -b.compare(a);
+    return 0;
+};
+
+/**
+    Creates a deep copy of any value.  Values, being immutable, are
+    returned without alternation.  Forwards to <code>clone</code> on
+    objects and arrays.
+
+    @function external:Object.clone
+    @param {Any} value a value to clone
+    @param {Number} depth an optional traversal depth, defaults to infinity.
+    A value of <code>0</code> means to make no clone and return the value
+    directly.
+    @param {Map} memo an optional memo of already visited objects to preserve
+    reference cycles.  The cloned object will have the exact same shape as the
+    original, but no identical objects.  Te map may be later used to associate
+    all objects in the original object graph with their corresponding member of
+    the cloned graph.
+    @returns a copy of the value
+*/
+Object.clone = function (value, depth, memo) {
+    value = Object.getValueOf(value);
+    memo = memo || new WeakMap();
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return value;
+    }
+    if (Object.isObject(value)) {
+        if (!memo.has(value)) {
+            if (value && typeof value.clone === "function") {
+                memo.set(value, value.clone(depth, memo));
+            } else {
+                var prototype = Object.getPrototypeOf(value);
+                if (prototype === null || prototype === Object.prototype) {
+                    var clone = Object.create(prototype);
+                    memo.set(value, clone);
+                    for (var key in value) {
+                        clone[key] = Object.clone(value[key], depth - 1, memo);
+                    }
+                } else {
+                    throw new Error("Can't clone " + value);
+                }
+            }
+        }
+        return memo.get(value);
+    }
+    return value;
+};
+
+/**
+    Removes all properties owned by this object making the object suitable for
+    reuse.
+
+    @function external:Object.clear
+    @returns this
+*/
+Object.clear = function (object) {
+    if (object && typeof object.clear === "function") {
+        object.clear();
+    } else {
+        var keys = Object.keys(object),
+            i = keys.length;
+        while (i) {
+            i--;
+            delete object[keys[i]];
+        }
+    }
+    return object;
+};
+
+
+},{"weak-map":16}],21:[function(require,module,exports){
+
+/**
+    accepts a string; returns the string with regex metacharacters escaped.
+    the returned string can safely be used within a regex to match a literal
+    string. escaped characters are [, ], {, }, (, ), -, *, +, ?, ., \, ^, $,
+    |, #, [comma], and whitespace.
+*/
+if (!RegExp.escape) {
+    var special = /[-[\]{}()*+?.\\^$|,#\s]/g;
+    RegExp.escape = function (string) {
+        return string.replace(special, "\\$&");
+    };
+}
+
+
+},{}],22:[function(require,module,exports){
+
+var Array = require("./shim-array");
+var Object = require("./shim-object");
+var Function = require("./shim-function");
+var RegExp = require("./shim-regexp");
+
+
+},{"./shim-array":18,"./shim-function":19,"./shim-object":20,"./shim-regexp":21}],23:[function(require,module,exports){
+"use strict";
+
+module.exports = SortedSet;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+var TreeLog = require("./tree-log");
+
+function SortedSet(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedSet)) {
+        return new SortedSet(values, equals, compare, getDefault);
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.getDefault = getDefault || Function.noop;
+    this.root = null;
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-set").SortedSet will work in MontageJS
+SortedSet.SortedSet = SortedSet;
+
+Object.addEach(SortedSet.prototype, GenericCollection.prototype);
+Object.addEach(SortedSet.prototype, GenericSet.prototype);
+Object.addEach(SortedSet.prototype, PropertyChanges.prototype);
+Object.addEach(SortedSet.prototype, RangeChanges.prototype);
+
+SortedSet.prototype.isSorted = true;
+
+SortedSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+
+SortedSet.prototype.has = function (value, equals) {
+    if (equals) {
+        throw new Error("SortedSet#has does not support second argument: equals");
+    }
+    if (this.root) {
+        this.splay(value);
+        return this.contentEquals(value, this.root.value);
+    } else {
+        return false;
+    }
+};
+
+SortedSet.prototype.get = function (value, equals) {
+    if (equals) {
+        throw new Error("SortedSet#get does not support second argument: equals");
+    }
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root.value;
+        }
+    }
+    return this.getDefault(value);
+};
+
+SortedSet.prototype.add = function (value) {
+    var node = new this.Node(value);
+    if (this.root) {
+        this.splay(value);
+        if (!this.contentEquals(value, this.root.value)) {
+            var comparison = this.contentCompare(value, this.root.value);
+            if (comparison === 0) {
+                throw new Error("SortedSet cannot contain incomparable but inequal values: " + value + " and " + this.root.value);
+            }
+            if (this.dispatchesRangeChanges) {
+                this.dispatchBeforeRangeChange([value], [], this.root.index);
+            }
+            if (comparison < 0) {
+                // rotate right
+                //   R        N
+                //  / \  ->  / \
+                // l   r    l   R
+                // :   :    :    \
+                //                r
+                //                :
+                node.right = this.root;
+                node.left = this.root.left;
+                this.root.left = null;
+                this.root.touch();
+            } else {
+                // rotate left
+                //   R        N
+                //  / \  ->  / \
+                // l   r    R   r
+                // :   :   /    :
+                //        l
+                //        :
+                node.left = this.root;
+                node.right = this.root.right;
+                this.root.right = null;
+                this.root.touch();
+            }
+            node.touch();
+            this.root = node;
+            this.length++;
+            if (this.dispatchesRangeChanges) {
+                this.dispatchRangeChange([value], [], this.root.index);
+            }
+            return true;
+        }
+    } else {
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([value], [], 0);
+        }
+        this.root = node;
+        this.length++;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([value], [], 0);
+        }
+        return true;
+    }
+    return false;
+};
+
+SortedSet.prototype['delete'] = function (value, equals) {
+    if (equals) {
+        throw new Error("SortedSet#delete does not support second argument: equals");
+    }
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            var index = this.root.index;
+            if (this.dispatchesRangeChanges) {
+                this.dispatchBeforeRangeChange([], [value], index);
+            }
+            if (!this.root.left) {
+                this.root = this.root.right;
+            } else {
+                // remove the right side of the tree,
+                var right = this.root.right;
+                this.root = this.root.left;
+                // the tree now only contains the left side of the tree, so all
+                // values are less than the value deleted.
+                // splay so that the root has an empty right child
+                this.splay(value);
+                // put the right side of the tree back
+                this.root.right = right;
+            }
+            this.length--;
+            if (this.root) {
+                this.root.touch();
+            }
+            if (this.dispatchesRangeChanges) {
+                this.dispatchRangeChange([], [value], index);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+SortedSet.prototype.indexOf = function (value, index) {
+    if (index) {
+        throw new Error("SortedSet#indexOf does not support second argument: startIndex");
+    }
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root.index;
+        }
+    }
+    return -1;
+};
+
+SortedSet.prototype.find = function (value, equals, index) {
+    if (equals) {
+        throw new Error("SortedSet#find does not support second argument: equals");
+    }
+    if (index) {
+        // TODO contemplate using splayIndex to isolate a subtree in
+        // which to search.
+        throw new Error("SortedSet#find does not support third argument: index");
+    }
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root;
+        }
+    }
+};
+
+SortedSet.prototype.findGreatest = function (at) {
+    if (this.root) {
+        at = at || this.root;
+        while (at.right) {
+            at = at.right;
+        }
+        return at;
+    }
+};
+
+SortedSet.prototype.findLeast = function (at) {
+    if (this.root) {
+        at = at || this.root;
+        while (at.left) {
+            at = at.left;
+        }
+        return at;
+    }
+};
+
+SortedSet.prototype.findGreatestLessThanOrEqual = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentCompare(this.root.value, value) > 0) {
+            return this.root.getPrevious();
+        } else {
+            return this.root;
+        }
+    }
+};
+
+SortedSet.prototype.findGreatestLessThan = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentCompare(this.root.value, value) >= 0) {
+            return this.root.getPrevious();
+        } else {
+            return this.root;
+        }
+    }
+};
+
+SortedSet.prototype.findLeastGreaterThanOrEqual = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentCompare(this.root.value, value) >= 0) {
+            return this.root;
+        } else {
+            return this.root.getNext();
+        }
+    }
+};
+
+SortedSet.prototype.findLeastGreaterThan = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentCompare(this.root.value, value) <= 0) {
+            return this.root.getNext();
+        } else {
+            return this.root;
+        }
+    }
+};
+
+SortedSet.prototype.pop = function () {
+    if (this.root) {
+        var found = this.findGreatest();
+        this["delete"](found.value);
+        return found.value;
+    }
+};
+
+SortedSet.prototype.shift = function () {
+    if (this.root) {
+        var found = this.findLeast();
+        this["delete"](found.value);
+        return found.value;
+    }
+};
+
+SortedSet.prototype.push = function () {
+    this.addEach(arguments);
+};
+
+SortedSet.prototype.unshift = function () {
+    this.addEach(arguments);
+};
+
+SortedSet.prototype.slice = function (start, end) {
+    var temp;
+    start = start || 0;
+    end = end || this.length;
+    if (start < 0) {
+        start += this.length;
+    }
+    if (end < 0) {
+        end += this.length;
+    }
+    var sliced = [];
+    if (this.root) {
+        this.splayIndex(start);
+        while (this.root.index < end) {
+            sliced.push(this.root.value);
+            if (!this.root.right) {
+                break;
+            }
+            this.splay(this.root.getNext().value);
+        }
+    }
+    return sliced;
+};
+
+SortedSet.prototype.splice = function (at, length /*...plus*/) {
+    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
+};
+
+SortedSet.prototype.swap = function (start, length, plus) {
+    if (start === undefined && length === undefined) {
+        return [];
+    }
+    start = start || 0;
+    if (start < 0) {
+        start += this.length;
+    }
+    if (length === undefined) {
+        length = Infinity;
+    }
+    var swapped = [];
+
+    if (this.root) {
+
+        // start
+        this.splayIndex(start);
+
+        // minus length
+        for (var i = 0; i < length; i++) {
+            swapped.push(this.root.value);
+            var next = this.root.getNext();
+            this["delete"](this.root.value);
+            if (!next) {
+                break;
+            }
+            this.splay(next.value);
+        }
+    }
+
+    // plus
+    this.addEach(plus);
+
+    return swapped;
+};
+
+// This is the simplified top-down splaying algorithm from: "Self-adjusting
+// Binary Search Trees" by Sleator and Tarjan. Guarantees that root.value
+// equals value if value exists. If value does not exist, then root will be
+// the node whose value either immediately preceeds or immediately follows value.
+// - as described in https://github.com/hij1nx/forest
+SortedSet.prototype.splay = function (value) {
+    var stub, left, right, temp, root, history;
+
+    if (!this.root) {
+        return;
+    }
+
+    // Create a stub node.  The use of the stub node is a bit
+    // counter-intuitive: The right child of the stub node will hold the L tree
+    // of the algorithm.  The left child of the stub node will hold the R tree
+    // of the algorithm.  Using a stub node, left and right will always be
+    // nodes and we avoid special cases.
+    // - http://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/splay-tree-inl.h
+    stub = left = right = new this.Node();
+    // The history is an upside down tree used to propagate new tree sizes back
+    // up the left and right arms of a traversal.  The right children of the
+    // transitive left side of the tree will be former roots while linking
+    // left.  The left children of the transitive walk to the right side of the
+    // history tree will all be previous roots from linking right.  The last
+    // node of the left and right traversal will each become a child of the new
+    // root.
+    history = new this.Node();
+    root = this.root;
+
+    while (true) {
+        var comparison = this.contentCompare(value, root.value);
+        if (comparison < 0) {
+            if (root.left) {
+                if (this.contentCompare(value, root.left.value) < 0) {
+                    // rotate right
+                    //        Root         L(temp)
+                    //      /     \       / \
+                    //     L(temp) R    LL    Root
+                    //    / \                /    \
+                    //  LL   LR            LR      R
+                    temp = root.left;
+                    root.left = temp.right;
+                    root.touch();
+                    temp.right = root;
+                    temp.touch();
+                    root = temp;
+                    if (!root.left) {
+                        break;
+                    }
+                }
+                // remember former root for repropagating length
+                temp = new Node();
+                temp.right = root;
+                temp.left = history.left;
+                history.left = temp;
+                // link left
+                right.left = root;
+                right.touch();
+                right = root;
+                root = root.left;
+            } else {
+                break;
+            }
+        } else if (comparison > 0) {
+            if (root.right) {
+                if (this.contentCompare(value, root.right.value) > 0) {
+                    // rotate left
+                    //        Root         L(temp)
+                    //      /     \       / \
+                    //     L(temp) R    LL    Root
+                    //    / \                /    \
+                    //  LL   LR            LR      R
+                    temp = root.right;
+                    root.right = temp.left;
+                    root.touch();
+                    temp.left = root;
+                    temp.touch();
+                    root = temp;
+                    if (!root.right) {
+                        break;
+                    }
+                }
+                // remember former root for repropagating length
+                temp = new Node();
+                temp.left = root;
+                temp.right = history.right;
+                history.right = temp;
+                // link right
+                left.right = root;
+                left.touch();
+                left = root;
+                root = root.right;
+            } else {
+                break;
+            }
+        } else { // equal or incomparable
+            break;
+        }
+    }
+
+    // reassemble
+    left.right = root.left;
+    left.touch();
+    right.left = root.right;
+    right.touch();
+    root.left = stub.right;
+    root.right = stub.left;
+
+    // propagate new lengths
+    while (history.left) {
+        history.left.right.touch();
+        history.left = history.left.left;
+    }
+    while (history.right) {
+        history.right.left.touch();
+        history.right = history.right.right;
+    }
+    root.touch();
+
+    this.root = root;
+};
+
+// an internal utility for splaying a node based on its index
+SortedSet.prototype.splayIndex = function (index) {
+    if (this.root) {
+        var at = this.root;
+        var atIndex = this.root.index;
+
+        while (atIndex !== index) {
+            if (atIndex > index && at.left) {
+                at = at.left;
+                atIndex -= 1 + (at.right ? at.right.length : 0);
+            } else if (atIndex < index && at.right) {
+                at = at.right;
+                atIndex += 1 + (at.left ? at.left.length : 0);
+            } else {
+                break;
+            }
+        }
+
+        this.splay(at.value);
+
+        return this.root.index === index;
+    }
+    return false;
+};
+
+SortedSet.prototype.reduce = function (callback, basis, thisp) {
+    if (this.root) {
+        basis = this.root.reduce(callback, basis, 0, thisp, this);
+    }
+    return basis;
+};
+
+SortedSet.prototype.reduceRight = function (callback, basis, thisp) {
+    if (this.root) {
+        basis = this.root.reduceRight(callback, basis, this.length - 1, thisp, this);
+    }
+    return basis;
+};
+
+SortedSet.prototype.min = function (at) {
+    var least = this.findLeast(at);
+    if (least) {
+        return least.value;
+    }
+};
+
+SortedSet.prototype.max = function (at) {
+    var greatest = this.findGreatest(at);
+    if (greatest) {
+        return greatest.value;
+    }
+};
+
+SortedSet.prototype.one = function () {
+    return this.min();
+};
+
+SortedSet.prototype.clear = function () {
+    var minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.toArray();
+        this.dispatchBeforeRangeChange([], minus, 0);
+    }
+    this.root = null;
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], minus, 0);
+    }
+};
+
+SortedSet.prototype.iterate = function (start, end) {
+    return new this.Iterator(this, start, end);
+};
+
+SortedSet.prototype.Iterator = Iterator;
+
+SortedSet.prototype.summary = function () {
+    if (this.root) {
+        return this.root.summary();
+    } else {
+        return "()";
+    }
+};
+
+SortedSet.prototype.log = function (charmap, logNode, callback, thisp) {
+    charmap = charmap || TreeLog.unicodeRound;
+    logNode = logNode || this.logNode;
+    if (!callback) {
+        callback = console.log;
+        thisp = console;
+    }
+    callback = callback.bind(thisp);
+    if (this.root) {
+        this.root.log(charmap, logNode, callback, callback);
+    }
+};
+
+SortedSet.prototype.logNode = function (node, log, logBefore) {
+    log(" " + node.value);
+};
+
+SortedSet.logCharsets = TreeLog;
+
+SortedSet.prototype.Node = Node;
+
+function Node(value) {
+    this.value = value;
+    this.left = null;
+    this.right = null;
+    this.length = 1;
+}
+
+// TODO case where no basis is provided for reduction
+
+Node.prototype.reduce = function (callback, basis, index, thisp, tree, depth) {
+    depth = depth || 0;
+    if (this.left) {
+        // prerecord length to be resistant to mutation
+        var length = this.left.length;
+        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
+        index += length;
+    }
+    basis = callback.call(thisp, basis, this.value, index, tree, this, depth);
+    index += 1;
+    if (this.right) {
+        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
+    }
+    return basis;
+};
+
+Node.prototype.reduceRight = function (callback, basis, index, thisp, tree, depth) {
+    depth = depth || 0;
+    if (this.right) {
+        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
+        index -= this.right.length;
+    }
+    basis = callback.call(thisp, basis, this.value, this.value, tree, this, depth);
+    index -= 1;
+    if (this.left) {
+        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
+    }
+    return basis;
+};
+
+Node.prototype.touch = function () {
+    this.length = 1 +
+        (this.left ? this.left.length : 0) +
+        (this.right ? this.right.length : 0);
+    this.index = this.left ? this.left.length : 0;
+};
+
+Node.prototype.checkIntegrity = function () {
+    var length = 1;
+    length += this.left ? this.left.checkIntegrity() : 0;
+    length += this.right ? this.right.checkIntegrity() : 0;
+    if (this.length !== length)
+        throw new Error("Integrity check failed: " + this.summary());
+    return length;
+}
+
+// get the next node in this subtree
+Node.prototype.getNext = function () {
+    var node = this;
+    if (node.right) {
+        node = node.right;
+        while (node.left) {
+            node = node.left;
+        }
+        return node;
+    }
+};
+
+// get the previous node in this subtree
+Node.prototype.getPrevious = function () {
+    var node = this;
+    if (node.left) {
+        node = node.left;
+        while (node.right) {
+            node = node.right;
+        }
+        return node;
+    }
+};
+
+Node.prototype.summary = function () {
+    var value = this.value || "-";
+    value += " <" + this.length;
+    if (!this.left && !this.right) {
+        return "(" + value + ")";
+    }
+    return "(" + value + " " + (
+        this.left ? this.left.summary() : "()"
+    ) + ", " + (
+        this.right ? this.right.summary() : "()"
+    ) + ")";
+};
+
+Node.prototype.log = function (charmap, logNode, log, logAbove) {
+    var self = this;
+
+    var branch;
+    if (this.left && this.right) {
+        branch = charmap.intersection;
+    } else if (this.left) {
+        branch = charmap.branchUp;
+    } else if (this.right) {
+        branch = charmap.branchDown;
+    } else {
+        branch = charmap.through;
+    }
+
+    var loggedAbove;
+    this.left && this.left.log(
+        charmap,
+        logNode,
+        function innerWrite(line) {
+            if (!loggedAbove) {
+                loggedAbove = true;
+                // leader
+                logAbove(charmap.fromBelow + charmap.through + line);
+            } else {
+                // below
+                logAbove(charmap.strafe + " " + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            // above
+            logAbove("  " + line);
+        }
+    );
+
+    var loggedOn;
+    logNode(
+        this,
+        function innerWrite(line) {
+            if (!loggedOn) {
+                loggedOn = true;
+                log(branch + line);
+            } else {
+                log((self.right ? charmap.strafe : " ") + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            logAbove((self.left ? charmap.strafe : " ") + line);
+        }
+    );
+
+    var loggedBelow;
+    this.right && this.right.log(
+        charmap,
+        logNode,
+        function innerWrite(line) {
+            if (!loggedBelow) {
+                loggedBelow = true;
+                log(charmap.fromAbove + charmap.through + line);
+            } else {
+                log("  " + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            log(charmap.strafe + " " + line);
+        }
+    );
+};
+
+function Iterator(set, start, end) {
+    this.set = set;
+    this.prev = null;
+    this.end = end;
+    if (start) {
+        var next = this.set.findLeastGreaterThanOrEqual(start);
+        if (next) {
+            this.set.splay(next.value);
+            this.prev = next.getPrevious();
+        }
+    }
+}
+
+Iterator.prototype.next = function () {
+    var next;
+    if (this.prev) {
+        next = this.set.findLeastGreaterThan(this.prev.value);
+    } else {
+        next = this.set.findLeast();
+    }
+    if (!next) {
+        throw StopIteration;
+    }
+    if (
+        this.end !== undefined &&
+        this.set.contentCompare(next.value, this.end) >= 0
+    ) {
+        throw StopIteration;
+    }
+    this.prev = next;
+    return next.value;
+};
+
+
+},{"./generic-collection":8,"./generic-set":11,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22,"./tree-log":24}],24:[function(require,module,exports){
+"use strict";
+
+module.exports = TreeLog;
+
+function TreeLog() {
+}
+
+TreeLog.ascii = {
+    intersection: "+",
+    through: "-",
+    branchUp: "+",
+    branchDown: "+",
+    fromBelow: ".",
+    fromAbove: "'",
+    fromBoth: "+",
+    strafe: "|"
+};
+
+TreeLog.unicodeRound = {
+    intersection: "\u254b",
+    through: "\u2501",
+    branchUp: "\u253b",
+    branchDown: "\u2533",
+    fromBelow: "\u256d", // round corner
+    fromAbove: "\u2570", // round corner
+    fromBoth: "\u2523",
+    strafe: "\u2503"
+};
+
+TreeLog.unicodeSharp = {
+    intersection: "\u254b",
+    through: "\u2501",
+    branchUp: "\u253b",
+    branchDown: "\u2533",
+    fromBelow: "\u250f", // sharp corner
+    fromAbove: "\u2517", // sharp corner
+    fromBoth: "\u2523",
+    strafe: "\u2503"
+};
+
+
+},{}],25:[function(require,module,exports){
+!function() {
+  var d3 = {
+    version: "3.5.17"
+  };
+  var d3_arraySlice = [].slice, d3_array = function(list) {
+    return d3_arraySlice.call(list);
+  };
+  var d3_document = this.document;
+  function d3_documentElement(node) {
+    return node && (node.ownerDocument || node.document || node).documentElement;
+  }
+  function d3_window(node) {
+    return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
+  }
+  if (d3_document) {
+    try {
+      d3_array(d3_document.documentElement.childNodes)[0].nodeType;
+    } catch (e) {
+      d3_array = function(list) {
+        var i = list.length, array = new Array(i);
+        while (i--) array[i] = list[i];
+        return array;
+      };
+    }
+  }
+  if (!Date.now) Date.now = function() {
+    return +new Date();
+  };
+  if (d3_document) {
+    try {
+      d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
+    } catch (error) {
+      var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
+      d3_element_prototype.setAttribute = function(name, value) {
+        d3_element_setAttribute.call(this, name, value + "");
+      };
+      d3_element_prototype.setAttributeNS = function(space, local, value) {
+        d3_element_setAttributeNS.call(this, space, local, value + "");
+      };
+      d3_style_prototype.setProperty = function(name, value, priority) {
+        d3_style_setProperty.call(this, name, value + "", priority);
+      };
+    }
+  }
+  d3.ascending = d3_ascending;
+  function d3_ascending(a, b) {
+    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+  }
+  d3.descending = function(a, b) {
+    return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+  };
+  d3.min = function(array, f) {
+    var i = -1, n = array.length, a, b;
+    if (arguments.length === 1) {
+      while (++i < n) if ((b = array[i]) != null && b >= b) {
+        a = b;
+        break;
+      }
+      while (++i < n) if ((b = array[i]) != null && a > b) a = b;
+    } else {
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+        a = b;
+        break;
+      }
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
+    }
+    return a;
+  };
+  d3.max = function(array, f) {
+    var i = -1, n = array.length, a, b;
+    if (arguments.length === 1) {
+      while (++i < n) if ((b = array[i]) != null && b >= b) {
+        a = b;
+        break;
+      }
+      while (++i < n) if ((b = array[i]) != null && b > a) a = b;
+    } else {
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+        a = b;
+        break;
+      }
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
+    }
+    return a;
+  };
+  d3.extent = function(array, f) {
+    var i = -1, n = array.length, a, b, c;
+    if (arguments.length === 1) {
+      while (++i < n) if ((b = array[i]) != null && b >= b) {
+        a = c = b;
+        break;
+      }
+      while (++i < n) if ((b = array[i]) != null) {
+        if (a > b) a = b;
+        if (c < b) c = b;
+      }
+    } else {
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+        a = c = b;
+        break;
+      }
+      while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
+        if (a > b) a = b;
+        if (c < b) c = b;
+      }
+    }
+    return [ a, c ];
+  };
+  function d3_number(x) {
+    return x === null ? NaN : +x;
+  }
+  function d3_numeric(x) {
+    return !isNaN(x);
+  }
+  d3.sum = function(array, f) {
+    var s = 0, n = array.length, a, i = -1;
+    if (arguments.length === 1) {
+      while (++i < n) if (d3_numeric(a = +array[i])) s += a;
+    } else {
+      while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;
+    }
+    return s;
+  };
+  d3.mean = function(array, f) {
+    var s = 0, n = array.length, a, i = -1, j = n;
+    if (arguments.length === 1) {
+      while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;
+    } else {
+      while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;
+    }
+    if (j) return s / j;
+  };
+  d3.quantile = function(values, p) {
+    var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
+    return e ? v + e * (values[h] - v) : v;
+  };
+  d3.median = function(array, f) {
+    var numbers = [], n = array.length, a, i = -1;
+    if (arguments.length === 1) {
+      while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);
+    } else {
+      while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);
+    }
+    if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);
+  };
+  d3.variance = function(array, f) {
+    var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;
+    if (arguments.length === 1) {
+      while (++i < n) {
+        if (d3_numeric(a = d3_number(array[i]))) {
+          d = a - m;
+          m += d / ++j;
+          s += d * (a - m);
+        }
+      }
+    } else {
+      while (++i < n) {
+        if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {
+          d = a - m;
+          m += d / ++j;
+          s += d * (a - m);
+        }
+      }
+    }
+    if (j > 1) return s / (j - 1);
+  };
+  d3.deviation = function() {
+    var v = d3.variance.apply(this, arguments);
+    return v ? Math.sqrt(v) : v;
+  };
+  function d3_bisector(compare) {
+    return {
+      left: function(a, x, lo, hi) {
+        if (arguments.length < 3) lo = 0;
+        if (arguments.length < 4) hi = a.length;
+        while (lo < hi) {
+          var mid = lo + hi >>> 1;
+          if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;
+        }
+        return lo;
+      },
+      right: function(a, x, lo, hi) {
+        if (arguments.length < 3) lo = 0;
+        if (arguments.length < 4) hi = a.length;
+        while (lo < hi) {
+          var mid = lo + hi >>> 1;
+          if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;
+        }
+        return lo;
+      }
+    };
+  }
+  var d3_bisect = d3_bisector(d3_ascending);
+  d3.bisectLeft = d3_bisect.left;
+  d3.bisect = d3.bisectRight = d3_bisect.right;
+  d3.bisector = function(f) {
+    return d3_bisector(f.length === 1 ? function(d, x) {
+      return d3_ascending(f(d), x);
+    } : f);
+  };
+  d3.shuffle = function(array, i0, i1) {
+    if ((m = arguments.length) < 3) {
+      i1 = array.length;
+      if (m < 2) i0 = 0;
+    }
+    var m = i1 - i0, t, i;
+    while (m) {
+      i = Math.random() * m-- | 0;
+      t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;
+    }
+    return array;
+  };
+  d3.permute = function(array, indexes) {
+    var i = indexes.length, permutes = new Array(i);
+    while (i--) permutes[i] = array[indexes[i]];
+    return permutes;
+  };
+  d3.pairs = function(array) {
+    var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
+    while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];
+    return pairs;
+  };
+  d3.transpose = function(matrix) {
+    if (!(n = matrix.length)) return [];
+    for (var i = -1, m = d3.min(matrix, d3_transposeLength), transpose = new Array(m); ++i < m; ) {
+      for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n; ) {
+        row[j] = matrix[j][i];
+      }
+    }
+    return transpose;
+  };
+  function d3_transposeLength(d) {
+    return d.length;
+  }
+  d3.zip = function() {
+    return d3.transpose(arguments);
+  };
+  d3.keys = function(map) {
+    var keys = [];
+    for (var key in map) keys.push(key);
+    return keys;
+  };
+  d3.values = function(map) {
+    var values = [];
+    for (var key in map) values.push(map[key]);
+    return values;
+  };
+  d3.entries = function(map) {
+    var entries = [];
+    for (var key in map) entries.push({
+      key: key,
+      value: map[key]
+    });
+    return entries;
+  };
+  d3.merge = function(arrays) {
+    var n = arrays.length, m, i = -1, j = 0, merged, array;
+    while (++i < n) j += arrays[i].length;
+    merged = new Array(j);
+    while (--n >= 0) {
+      array = arrays[n];
+      m = array.length;
+      while (--m >= 0) {
+        merged[--j] = array[m];
+      }
+    }
+    return merged;
+  };
+  var abs = Math.abs;
+  d3.range = function(start, stop, step) {
+    if (arguments.length < 3) {
+      step = 1;
+      if (arguments.length < 2) {
+        stop = start;
+        start = 0;
+      }
+    }
+    if ((stop - start) / step === Infinity) throw new Error("infinite range");
+    var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;
+    start *= k, stop *= k, step *= k;
+    if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
+    return range;
+  };
+  function d3_range_integerScale(x) {
+    var k = 1;
+    while (x * k % 1) k *= 10;
+    return k;
+  }
+  function d3_class(ctor, properties) {
+    for (var key in properties) {
+      Object.defineProperty(ctor.prototype, key, {
+        value: properties[key],
+        enumerable: false
+      });
+    }
+  }
+  d3.map = function(object, f) {
+    var map = new d3_Map();
+    if (object instanceof d3_Map) {
+      object.forEach(function(key, value) {
+        map.set(key, value);
+      });
+    } else if (Array.isArray(object)) {
+      var i = -1, n = object.length, o;
+      if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);
+    } else {
+      for (var key in object) map.set(key, object[key]);
+    }
+    return map;
+  };
+  function d3_Map() {
+    this._ = Object.create(null);
+  }
+  var d3_map_proto = "__proto__", d3_map_zero = "\x00";
+  d3_class(d3_Map, {
+    has: d3_map_has,
+    get: function(key) {
+      return this._[d3_map_escape(key)];
+    },
+    set: function(key, value) {
+      return this._[d3_map_escape(key)] = value;
+    },
+    remove: d3_map_remove,
+    keys: d3_map_keys,
+    values: function() {
+      var values = [];
+      for (var key in this._) values.push(this._[key]);
+      return values;
+    },
+    entries: function() {
+      var entries = [];
+      for (var key in this._) entries.push({
+        key: d3_map_unescape(key),
+        value: this._[key]
+      });
+      return entries;
+    },
+    size: d3_map_size,
+    empty: d3_map_empty,
+    forEach: function(f) {
+      for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);
+    }
+  });
+  function d3_map_escape(key) {
+    return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
+  }
+  function d3_map_unescape(key) {
+    return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
+  }
+  function d3_map_has(key) {
+    return d3_map_escape(key) in this._;
+  }
+  function d3_map_remove(key) {
+    return (key = d3_map_escape(key)) in this._ && delete this._[key];
+  }
+  function d3_map_keys() {
+    var keys = [];
+    for (var key in this._) keys.push(d3_map_unescape(key));
+    return keys;
+  }
+  function d3_map_size() {
+    var size = 0;
+    for (var key in this._) ++size;
+    return size;
+  }
+  function d3_map_empty() {
+    for (var key in this._) return false;
+    return true;
+  }
+  d3.nest = function() {
+    var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
+    function map(mapType, array, depth) {
+      if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
+      var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
+      while (++i < n) {
+        if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
+          values.push(object);
+        } else {
+          valuesByKey.set(keyValue, [ object ]);
+        }
+      }
+      if (mapType) {
+        object = mapType();
+        setter = function(keyValue, values) {
+          object.set(keyValue, map(mapType, values, depth));
+        };
+      } else {
+        object = {};
+        setter = function(keyValue, values) {
+          object[keyValue] = map(mapType, values, depth);
+        };
+      }
+      valuesByKey.forEach(setter);
+      return object;
+    }
+    function entries(map, depth) {
+      if (depth >= keys.length) return map;
+      var array = [], sortKey = sortKeys[depth++];
+      map.forEach(function(key, keyMap) {
+        array.push({
+          key: key,
+          values: entries(keyMap, depth)
+        });
+      });
+      return sortKey ? array.sort(function(a, b) {
+        return sortKey(a.key, b.key);
+      }) : array;
+    }
+    nest.map = function(array, mapType) {
+      return map(mapType, array, 0);
+    };
+    nest.entries = function(array) {
+      return entries(map(d3.map, array, 0), 0);
+    };
+    nest.key = function(d) {
+      keys.push(d);
+      return nest;
+    };
+    nest.sortKeys = function(order) {
+      sortKeys[keys.length - 1] = order;
+      return nest;
+    };
+    nest.sortValues = function(order) {
+      sortValues = order;
+      return nest;
+    };
+    nest.rollup = function(f) {
+      rollup = f;
+      return nest;
+    };
+    return nest;
+  };
+  d3.set = function(array) {
+    var set = new d3_Set();
+    if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
+    return set;
+  };
+  function d3_Set() {
+    this._ = Object.create(null);
+  }
+  d3_class(d3_Set, {
+    has: d3_map_has,
+    add: function(key) {
+      this._[d3_map_escape(key += "")] = true;
+      return key;
+    },
+    remove: d3_map_remove,
+    values: d3_map_keys,
+    size: d3_map_size,
+    empty: d3_map_empty,
+    forEach: function(f) {
+      for (var key in this._) f.call(this, d3_map_unescape(key));
+    }
+  });
+  d3.behavior = {};
+  function d3_identity(d) {
+    return d;
+  }
+  d3.rebind = function(target, source) {
+    var i = 1, n = arguments.length, method;
+    while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
+    return target;
+  };
+  function d3_rebind(target, source, method) {
+    return function() {
+      var value = method.apply(source, arguments);
+      return value === source ? target : value;
+    };
+  }
+  function d3_vendorSymbol(object, name) {
+    if (name in object) return name;
+    name = name.charAt(0).toUpperCase() + name.slice(1);
+    for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
+      var prefixName = d3_vendorPrefixes[i] + name;
+      if (prefixName in object) return prefixName;
+    }
+  }
+  var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];
+  function d3_noop() {}
+  d3.dispatch = function() {
+    var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
+    while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+    return dispatch;
+  };
+  function d3_dispatch() {}
+  d3_dispatch.prototype.on = function(type, listener) {
+    var i = type.indexOf("."), name = "";
+    if (i >= 0) {
+      name = type.slice(i + 1);
+      type = type.slice(0, i);
+    }
+    if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
+    if (arguments.length === 2) {
+      if (listener == null) for (type in this) {
+        if (this.hasOwnProperty(type)) this[type].on(name, null);
+      }
+      return this;
+    }
+  };
+  function d3_dispatch_event(dispatch) {
+    var listeners = [], listenerByName = new d3_Map();
+    function event() {
+      var z = listeners, i = -1, n = z.length, l;
+      while (++i < n) if (l = z[i].on) l.apply(this, arguments);
+      return dispatch;
+    }
+    event.on = function(name, listener) {
+      var l = listenerByName.get(name), i;
+      if (arguments.length < 2) return l && l.on;
+      if (l) {
+        l.on = null;
+        listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
+        listenerByName.remove(name);
+      }
+      if (listener) listeners.push(listenerByName.set(name, {
+        on: listener
+      }));
+      return dispatch;
+    };
+    return event;
+  }
+  d3.event = null;
+  function d3_eventPreventDefault() {
+    d3.event.preventDefault();
+  }
+  function d3_eventSource() {
+    var e = d3.event, s;
+    while (s = e.sourceEvent) e = s;
+    return e;
+  }
+  function d3_eventDispatch(target) {
+    var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
+    while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+    dispatch.of = function(thiz, argumentz) {
+      return function(e1) {
+        try {
+          var e0 = e1.sourceEvent = d3.event;
+          e1.target = target;
+          d3.event = e1;
+          dispatch[e1.type].apply(thiz, argumentz);
+        } finally {
+          d3.event = e0;
+        }
+      };
+    };
+    return dispatch;
+  }
+  d3.requote = function(s) {
+    return s.replace(d3_requote_re, "\\$&");
+  };
+  var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
+  var d3_subclass = {}.__proto__ ? function(object, prototype) {
+    object.__proto__ = prototype;
+  } : function(object, prototype) {
+    for (var property in prototype) object[property] = prototype[property];
+  };
+  function d3_selection(groups) {
+    d3_subclass(groups, d3_selectionPrototype);
+    return groups;
+  }
+  var d3_select = function(s, n) {
+    return n.querySelector(s);
+  }, d3_selectAll = function(s, n) {
+    return n.querySelectorAll(s);
+  }, d3_selectMatches = function(n, s) {
+    var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
+    d3_selectMatches = function(n, s) {
+      return d3_selectMatcher.call(n, s);
+    };
+    return d3_selectMatches(n, s);
+  };
+  if (typeof Sizzle === "function") {
+    d3_select = function(s, n) {
+      return Sizzle(s, n)[0] || null;
+    };
+    d3_selectAll = Sizzle;
+    d3_selectMatches = Sizzle.matchesSelector;
+  }
+  d3.selection = function() {
+    return d3.select(d3_document.documentElement);
+  };
+  var d3_selectionPrototype = d3.selection.prototype = [];
+  d3_selectionPrototype.select = function(selector) {
+    var subgroups = [], subgroup, subnode, group, node;
+    selector = d3_selection_selector(selector);
+    for (var j = -1, m = this.length; ++j < m; ) {
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = (group = this[j]).parentNode;
+      for (var i = -1, n = group.length; ++i < n; ) {
+        if (node = group[i]) {
+          subgroup.push(subnode = selector.call(node, node.__data__, i, j));
+          if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+        } else {
+          subgroup.push(null);
+        }
+      }
+    }
+    return d3_selection(subgroups);
+  };
+  function d3_selection_selector(selector) {
+    return typeof selector === "function" ? selector : function() {
+      return d3_select(selector, this);
+    };
+  }
+  d3_selectionPrototype.selectAll = function(selector) {
+    var subgroups = [], subgroup, node;
+    selector = d3_selection_selectorAll(selector);
+    for (var j = -1, m = this.length; ++j < m; ) {
+      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+        if (node = group[i]) {
+          subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
+          subgroup.parentNode = node;
+        }
+      }
+    }
+    return d3_selection(subgroups);
+  };
+  function d3_selection_selectorAll(selector) {
+    return typeof selector === "function" ? selector : function() {
+      return d3_selectAll(selector, this);
+    };
+  }
+  var d3_nsXhtml = "http://www.w3.org/1999/xhtml";
+  var d3_nsPrefix = {
+    svg: "http://www.w3.org/2000/svg",
+    xhtml: d3_nsXhtml,
+    xlink: "http://www.w3.org/1999/xlink",
+    xml: "http://www.w3.org/XML/1998/namespace",
+    xmlns: "http://www.w3.org/2000/xmlns/"
+  };
+  d3.ns = {
+    prefix: d3_nsPrefix,
+    qualify: function(name) {
+      var i = name.indexOf(":"), prefix = name;
+      if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
+      return d3_nsPrefix.hasOwnProperty(prefix) ? {
+        space: d3_nsPrefix[prefix],
+        local: name
+      } : name;
+    }
+  };
+  d3_selectionPrototype.attr = function(name, value) {
+    if (arguments.length < 2) {
+      if (typeof name === "string") {
+        var node = this.node();
+        name = d3.ns.qualify(name);
+        return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
+      }
+      for (value in name) this.each(d3_selection_attr(value, name[value]));
+      return this;
+    }
+    return this.each(d3_selection_attr(name, value));
+  };
+  function d3_selection_attr(name, value) {
+    name = d3.ns.qualify(name);
+    function attrNull() {
+      this.removeAttribute(name);
+    }
+    function attrNullNS() {
+      this.removeAttributeNS(name.space, name.local);
+    }
+    function attrConstant() {
+      this.setAttribute(name, value);
+    }
+    function attrConstantNS() {
+      this.setAttributeNS(name.space, name.local, value);
+    }
+    function attrFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
+    }
+    function attrFunctionNS() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
+    }
+    return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
+  }
+  function d3_collapse(s) {
+    return s.trim().replace(/\s+/g, " ");
+  }
+  d3_selectionPrototype.classed = function(name, value) {
+    if (arguments.length < 2) {
+      if (typeof name === "string") {
+        var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;
+        if (value = node.classList) {
+          while (++i < n) if (!value.contains(name[i])) return false;
+        } else {
+          value = node.getAttribute("class");
+          while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
+        }
+        return true;
+      }
+      for (value in name) this.each(d3_selection_classed(value, name[value]));
+      return this;
+    }
+    return this.each(d3_selection_classed(name, value));
+  };
+  function d3_selection_classedRe(name) {
+    return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
+  }
+  function d3_selection_classes(name) {
+    return (name + "").trim().split(/^|\s+/);
+  }
+  function d3_selection_classed(name, value) {
+    name = d3_selection_classes(name).map(d3_selection_classedName);
+    var n = name.length;
+    function classedConstant() {
+      var i = -1;
+      while (++i < n) name[i](this, value);
+    }
+    function classedFunction() {
+      var i = -1, x = value.apply(this, arguments);
+      while (++i < n) name[i](this, x);
+    }
+    return typeof value === "function" ? classedFunction : classedConstant;
+  }
+  function d3_selection_classedName(name) {
+    var re = d3_selection_classedRe(name);
+    return function(node, value) {
+      if (c = node.classList) return value ? c.add(name) : c.remove(name);
+      var c = node.getAttribute("class") || "";
+      if (value) {
+        re.lastIndex = 0;
+        if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
+      } else {
+        node.setAttribute("class", d3_collapse(c.replace(re, " ")));
+      }
+    };
+  }
+  d3_selectionPrototype.style = function(name, value, priority) {
+    var n = arguments.length;
+    if (n < 3) {
+      if (typeof name !== "string") {
+        if (n < 2) value = "";
+        for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
+        return this;
+      }
+      if (n < 2) {
+        var node = this.node();
+        return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
+      }
+      priority = "";
+    }
+    return this.each(d3_selection_style(name, value, priority));
+  };
+  function d3_selection_style(name, value, priority) {
+    function styleNull() {
+      this.style.removeProperty(name);
+    }
+    function styleConstant() {
+      this.style.setProperty(name, value, priority);
+    }
+    function styleFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
+    }
+    return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
+  }
+  d3_selectionPrototype.property = function(name, value) {
+    if (arguments.length < 2) {
+      if (typeof name === "string") return this.node()[name];
+      for (value in name) this.each(d3_selection_property(value, name[value]));
+      return this;
+    }
+    return this.each(d3_selection_property(name, value));
+  };
+  function d3_selection_property(name, value) {
+    function propertyNull() {
+      delete this[name];
+    }
+    function propertyConstant() {
+      this[name] = value;
+    }
+    function propertyFunction() {
+      var x = value.apply(this, arguments);
+      if (x == null) delete this[name]; else this[name] = x;
+    }
+    return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
+  }
+  d3_selectionPrototype.text = function(value) {
+    return arguments.length ? this.each(typeof value === "function" ? function() {
+      var v = value.apply(this, arguments);
+      this.textContent = v == null ? "" : v;
+    } : value == null ? function() {
+      this.textContent = "";
+    } : function() {
+      this.textContent = value;
+    }) : this.node().textContent;
+  };
+  d3_selectionPrototype.html = function(value) {
+    return arguments.length ? this.each(typeof value === "function" ? function() {
+      var v = value.apply(this, arguments);
+      this.innerHTML = v == null ? "" : v;
+    } : value == null ? function() {
+      this.innerHTML = "";
+    } : function() {
+      this.innerHTML = value;
+    }) : this.node().innerHTML;
+  };
+  d3_selectionPrototype.append = function(name) {
+    name = d3_selection_creator(name);
+    return this.select(function() {
+      return this.appendChild(name.apply(this, arguments));
+    });
+  };
+  function d3_selection_creator(name) {
+    function create() {
+      var document = this.ownerDocument, namespace = this.namespaceURI;
+      return namespace === d3_nsXhtml && document.documentElement.namespaceURI === d3_nsXhtml ? document.createElement(name) : document.createElementNS(namespace, name);
+    }
+    function createNS() {
+      return this.ownerDocument.createElementNS(name.space, name.local);
+    }
+    return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create;
+  }
+  d3_selectionPrototype.insert = function(name, before) {
+    name = d3_selection_creator(name);
+    before = d3_selection_selector(before);
+    return this.select(function() {
+      return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
+    });
+  };
+  d3_selectionPrototype.remove = function() {
+    return this.each(d3_selectionRemove);
+  };
+  function d3_selectionRemove() {
+    var parent = this.parentNode;
+    if (parent) parent.removeChild(this);
+  }
+  d3_selectionPrototype.data = function(value, key) {
+    var i = -1, n = this.length, group, node;
+    if (!arguments.length) {
+      value = new Array(n = (group = this[0]).length);
+      while (++i < n) {
+        if (node = group[i]) {
+          value[i] = node.__data__;
+        }
+      }
+      return value;
+    }
+    function bind(group, groupData) {
+      var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;
+      if (key) {
+        var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;
+        for (i = -1; ++i < n; ) {
+          if (node = group[i]) {
+            if (nodeByKeyValue.has(keyValue = key.call(node, node.__data__, i))) {
+              exitNodes[i] = node;
+            } else {
+              nodeByKeyValue.set(keyValue, node);
+            }
+            keyValues[i] = keyValue;
+          }
+        }
+        for (i = -1; ++i < m; ) {
+          if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {
+            enterNodes[i] = d3_selection_dataNode(nodeData);
+          } else if (node !== true) {
+            updateNodes[i] = node;
+            node.__data__ = nodeData;
+          }
+          nodeByKeyValue.set(keyValue, true);
+        }
+        for (i = -1; ++i < n; ) {
+          if (i in keyValues && nodeByKeyValue.get(keyValues[i]) !== true) {
+            exitNodes[i] = group[i];
+          }
+        }
+      } else {
+        for (i = -1; ++i < n0; ) {
+          node = group[i];
+          nodeData = groupData[i];
+          if (node) {
+            node.__data__ = nodeData;
+            updateNodes[i] = node;
+          } else {
+            enterNodes[i] = d3_selection_dataNode(nodeData);
+          }
+        }
+        for (;i < m; ++i) {
+          enterNodes[i] = d3_selection_dataNode(groupData[i]);
+        }
+        for (;i < n; ++i) {
+          exitNodes[i] = group[i];
+        }
+      }
+      enterNodes.update = updateNodes;
+      enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
+      enter.push(enterNodes);
+      update.push(updateNodes);
+      exit.push(exitNodes);
+    }
+    var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
+    if (typeof value === "function") {
+      while (++i < n) {
+        bind(group = this[i], value.call(group, group.parentNode.__data__, i));
+      }
+    } else {
+      while (++i < n) {
+        bind(group = this[i], value);
+      }
+    }
+    update.enter = function() {
+      return enter;
+    };
+    update.exit = function() {
+      return exit;
+    };
+    return update;
+  };
+  function d3_selection_dataNode(data) {
+    return {
+      __data__: data
+    };
+  }
+  d3_selectionPrototype.datum = function(value) {
+    return arguments.length ? this.property("__data__", value) : this.property("__data__");
+  };
+  d3_selectionPrototype.filter = function(filter) {
+    var subgroups = [], subgroup, group, node;
+    if (typeof filter !== "function") filter = d3_selection_filter(filter);
+    for (var j = 0, m = this.length; j < m; j++) {
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = (group = this[j]).parentNode;
+      for (var i = 0, n = group.length; i < n; i++) {
+        if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+          subgroup.push(node);
+        }
+      }
+    }
+    return d3_selection(subgroups);
+  };
+  function d3_selection_filter(selector) {
+    return function() {
+      return d3_selectMatches(this, selector);
+    };
+  }
+  d3_selectionPrototype.order = function() {
+    for (var j = -1, m = this.length; ++j < m; ) {
+      for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
+        if (node = group[i]) {
+          if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
+          next = node;
+        }
+      }
+    }
+    return this;
+  };
+  d3_selectionPrototype.sort = function(comparator) {
+    comparator = d3_selection_sortComparator.apply(this, arguments);
+    for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
+    return this.order();
+  };
+  function d3_selection_sortComparator(comparator) {
+    if (!arguments.length) comparator = d3_ascending;
+    return function(a, b) {
+      return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
+    };
+  }
+  d3_selectionPrototype.each = function(callback) {
+    return d3_selection_each(this, function(node, i, j) {
+      callback.call(node, node.__data__, i, j);
+    });
+  };
+  function d3_selection_each(groups, callback) {
+    for (var j = 0, m = groups.length; j < m; j++) {
+      for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
+        if (node = group[i]) callback(node, i, j);
+      }
+    }
+    return groups;
+  }
+  d3_selectionPrototype.call = function(callback) {
+    var args = d3_array(arguments);
+    callback.apply(args[0] = this, args);
+    return this;
+  };
+  d3_selectionPrototype.empty = function() {
+    return !this.node();
+  };
+  d3_selectionPrototype.node = function() {
+    for (var j = 0, m = this.length; j < m; j++) {
+      for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+        var node = group[i];
+        if (node) return node;
+      }
+    }
+    return null;
+  };
+  d3_selectionPrototype.size = function() {
+    var n = 0;
+    d3_selection_each(this, function() {
+      ++n;
+    });
+    return n;
+  };
+  function d3_selection_enter(selection) {
+    d3_subclass(selection, d3_selection_enterPrototype);
+    return selection;
+  }
+  var d3_selection_enterPrototype = [];
+  d3.selection.enter = d3_selection_enter;
+  d3.selection.enter.prototype = d3_selection_enterPrototype;
+  d3_selection_enterPrototype.append = d3_selectionPrototype.append;
+  d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
+  d3_selection_enterPrototype.node = d3_selectionPrototype.node;
+  d3_selection_enterPrototype.call = d3_selectionPrototype.call;
+  d3_selection_enterPrototype.size = d3_selectionPrototype.size;
+  d3_selection_enterPrototype.select = function(selector) {
+    var subgroups = [], subgroup, subnode, upgroup, group, node;
+    for (var j = -1, m = this.length; ++j < m; ) {
+      upgroup = (group = this[j]).update;
+      subgroups.push(subgroup = []);
+      subgroup.parentNode = group.parentNode;
+      for (var i = -1, n = group.length; ++i < n; ) {
+        if (node = group[i]) {
+          subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
+          subnode.__data__ = node.__data__;
+        } else {
+          subgroup.push(null);
+        }
+      }
+    }
+    return d3_selection(subgroups);
+  };
+  d3_selection_enterPrototype.insert = function(name, before) {
+    if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
+    return d3_selectionPrototype.insert.call(this, name, before);
+  };
+  function d3_selection_enterInsertBefore(enter) {
+    var i0, j0;
+    return function(d, i, j) {
+      var group = enter[j].update, n = group.length, node;
+      if (j != j0) j0 = j, i0 = 0;
+      if (i >= i0) i0 = i + 1;
+      while (!(node = group[i0]) && ++i0 < n) ;
+      return node;
+    };
+  }
+  d3.select = function(node) {
+    var group;
+    if (typeof node === "string") {
+      group = [ d3_select(node, d3_document) ];
+      group.parentNode = d3_document.documentElement;
+    } else {
+      group = [ node ];
+      group.parentNode = d3_documentElement(node);
+    }
+    return d3_selection([ group ]);
+  };
+  d3.selectAll = function(nodes) {
+    var group;
+    if (typeof nodes === "string") {
+      group = d3_array(d3_selectAll(nodes, d3_document));
+      group.parentNode = d3_document.documentElement;
+    } else {
+      group = d3_array(nodes);
+      group.parentNode = null;
+    }
+    return d3_selection([ group ]);
+  };
+  d3_selectionPrototype.on = function(type, listener, capture) {
+    var n = arguments.length;
+    if (n < 3) {
+      if (typeof type !== "string") {
+        if (n < 2) listener = false;
+        for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
+        return this;
+      }
+      if (n < 2) return (n = this.node()["__on" + type]) && n._;
+      capture = false;
+    }
+    return this.each(d3_selection_on(type, listener, capture));
+  };
+  function d3_selection_on(type, listener, capture) {
+    var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
+    if (i > 0) type = type.slice(0, i);
+    var filter = d3_selection_onFilters.get(type);
+    if (filter) type = filter, wrap = d3_selection_onFilter;
+    function onRemove() {
+      var l = this[name];
+      if (l) {
+        this.removeEventListener(type, l, l.$);
+        delete this[name];
+      }
+    }
+    function onAdd() {
+      var l = wrap(listener, d3_array(arguments));
+      onRemove.call(this);
+      this.addEventListener(type, this[name] = l, l.$ = capture);
+      l._ = listener;
+    }
+    function removeAll() {
+      var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
+      for (var name in this) {
+        if (match = name.match(re)) {
+          var l = this[name];
+          this.removeEventListener(match[1], l, l.$);
+          delete this[name];
+        }
+      }
+    }
+    return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
+  }
+  var d3_selection_onFilters = d3.map({
+    mouseenter: "mouseover",
+    mouseleave: "mouseout"
+  });
+  if (d3_document) {
+    d3_selection_onFilters.forEach(function(k) {
+      if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
+    });
+  }
+  function d3_selection_onListener(listener, argumentz) {
+    return function(e) {
+      var o = d3.event;
+      d3.event = e;
+      argumentz[0] = this.__data__;
+      try {
+        listener.apply(this, argumentz);
+      } finally {
+        d3.event = o;
+      }
+    };
+  }
+  function d3_selection_onFilter(listener, argumentz) {
+    var l = d3_selection_onListener(listener, argumentz);
+    return function(e) {
+      var target = this, related = e.relatedTarget;
+      if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
+        l.call(target, e);
+      }
+    };
+  }
+  var d3_event_dragSelect, d3_event_dragId = 0;
+  function d3_event_dragSuppress(node) {
+    var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);
+    if (d3_event_dragSelect == null) {
+      d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect");
+    }
+    if (d3_event_dragSelect) {
+      var style = d3_documentElement(node).style, select = style[d3_event_dragSelect];
+      style[d3_event_dragSelect] = "none";
+    }
+    return function(suppressClick) {
+      w.on(name, null);
+      if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
+      if (suppressClick) {
+        var off = function() {
+          w.on(click, null);
+        };
+        w.on(click, function() {
+          d3_eventPreventDefault();
+          off();
+        }, true);
+        setTimeout(off, 0);
+      }
+    };
+  }
+  d3.mouse = function(container) {
+    return d3_mousePoint(container, d3_eventSource());
+  };
+  var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
+  function d3_mousePoint(container, e) {
+    if (e.changedTouches) e = e.changedTouches[0];
+    var svg = container.ownerSVGElement || container;
+    if (svg.createSVGPoint) {
+      var point = svg.createSVGPoint();
+      if (d3_mouse_bug44083 < 0) {
+        var window = d3_window(container);
+        if (window.scrollX || window.scrollY) {
+          svg = d3.select("body").append("svg").style({
+            position: "absolute",
+            top: 0,
+            left: 0,
+            margin: 0,
+            padding: 0,
+            border: "none"
+          }, "important");
+          var ctm = svg[0][0].getScreenCTM();
+          d3_mouse_bug44083 = !(ctm.f || ctm.e);
+          svg.remove();
+        }
+      }
+      if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, 
+      point.y = e.clientY;
+      point = point.matrixTransform(container.getScreenCTM().inverse());
+      return [ point.x, point.y ];
+    }
+    var rect = container.getBoundingClientRect();
+    return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
+  }
+  d3.touch = function(container, touches, identifier) {
+    if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
+    if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
+      if ((touch = touches[i]).identifier === identifier) {
+        return d3_mousePoint(container, touch);
+      }
+    }
+  };
+  d3.behavior.drag = function() {
+    var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");
+    function drag() {
+      this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
+    }
+    function dragstart(id, position, subject, move, end) {
+      return function() {
+        var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId);
+        if (origin) {
+          dragOffset = origin.apply(that, arguments);
+          dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];
+        } else {
+          dragOffset = [ 0, 0 ];
+        }
+        dispatch({
+          type: "dragstart"
+        });
+        function moved() {
+          var position1 = position(parent, dragId), dx, dy;
+          if (!position1) return;
+          dx = position1[0] - position0[0];
+          dy = position1[1] - position0[1];
+          dragged |= dx | dy;
+          position0 = position1;
+          dispatch({
+            type: "drag",
+            x: position1[0] + dragOffset[0],
+            y: position1[1] + dragOffset[1],
+            dx: dx,
+            dy: dy
+          });
+        }
+        function ended() {
+          if (!position(parent, dragId)) return;
+          dragSubject.on(move + dragName, null).on(end + dragName, null);
+          dragRestore(dragged);
+          dispatch({
+            type: "dragend"
+          });
+        }
+      };
+    }
+    drag.origin = function(x) {
+      if (!arguments.length) return origin;
+      origin = x;
+      return drag;
+    };
+    return d3.rebind(drag, event, "on");
+  };
+  function d3_behavior_dragTouchId() {
+    return d3.event.changedTouches[0].identifier;
+  }
+  d3.touches = function(container, touches) {
+    if (arguments.length < 2) touches = d3_eventSource().touches;
+    return touches ? d3_array(touches).map(function(touch) {
+      var point = d3_mousePoint(container, touch);
+      point.identifier = touch.identifier;
+      return point;
+    }) : [];
+  };
+  var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π;
+  function d3_sgn(x) {
+    return x > 0 ? 1 : x < 0 ? -1 : 0;
+  }
+  function d3_cross2d(a, b, c) {
+    return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  }
+  function d3_acos(x) {
+    return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
+  }
+  function d3_asin(x) {
+    return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
+  }
+  function d3_sinh(x) {
+    return ((x = Math.exp(x)) - 1 / x) / 2;
+  }
+  function d3_cosh(x) {
+    return ((x = Math.exp(x)) + 1 / x) / 2;
+  }
+  function d3_tanh(x) {
+    return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+  }
+  function d3_haversin(x) {
+    return (x = Math.sin(x / 2)) * x;
+  }
+  var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
+  d3.interpolateZoom = function(p0, p1) {
+    var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S;
+    if (d2 < ε2) {
+      S = Math.log(w1 / w0) / ρ;
+      i = function(t) {
+        return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * t * S) ];
+      };
+    } else {
+      var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+      S = (r1 - r0) / ρ;
+      i = function(t) {
+        var s = t * S, coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
+        return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];
+      };
+    }
+    i.duration = S * 1e3;
+    return i;
+  };
+  d3.behavior.zoom = function() {
+    var view = {
+      x: 0,
+      y: 0,
+      k: 1
+    }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
+    if (!d3_behavior_zoomWheel) {
+      d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+        return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
+      }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+        return d3.event.wheelDelta;
+      }, "mousewheel") : (d3_behavior_zoomDelta = function() {
+        return -d3.event.detail;
+      }, "MozMousePixelScroll");
+    }
+    function zoom(g) {
+      g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
+    }
+    zoom.event = function(g) {
+      g.each(function() {
+        var dispatch = event.of(this, arguments), view1 = view;
+        if (d3_transitionInheritId) {
+          d3.select(this).transition().each("start.zoom", function() {
+            view = this.__chart__ || {
+              x: 0,
+              y: 0,
+              k: 1
+            };
+            zoomstarted(dispatch);
+          }).tween("zoom:zoom", function() {
+            var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);
+            return function(t) {
+              var l = i(t), k = dx / l[2];
+              this.__chart__ = view = {
+                x: cx - l[0] * k,
+                y: cy - l[1] * k,
+                k: k
+              };
+              zoomed(dispatch);
+            };
+          }).each("interrupt.zoom", function() {
+            zoomended(dispatch);
+          }).each("end.zoom", function() {
+            zoomended(dispatch);
+          });
+        } else {
+          this.__chart__ = view;
+          zoomstarted(dispatch);
+          zoomed(dispatch);
+          zoomended(dispatch);
+        }
+      });
+    };
+    zoom.translate = function(_) {
+      if (!arguments.length) return [ view.x, view.y ];
+      view = {
+        x: +_[0],
+        y: +_[1],
+        k: view.k
+      };
+      rescale();
+      return zoom;
+    };
+    zoom.scale = function(_) {
+      if (!arguments.length) return view.k;
+      view = {
+        x: view.x,
+        y: view.y,
+        k: null
+      };
+      scaleTo(+_);
+      rescale();
+      return zoom;
+    };
+    zoom.scaleExtent = function(_) {
+      if (!arguments.length) return scaleExtent;
+      scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];
+      return zoom;
+    };
+    zoom.center = function(_) {
+      if (!arguments.length) return center;
+      center = _ && [ +_[0], +_[1] ];
+      return zoom;
+    };
+    zoom.size = function(_) {
+      if (!arguments.length) return size;
+      size = _ && [ +_[0], +_[1] ];
+      return zoom;
+    };
+    zoom.duration = function(_) {
+      if (!arguments.length) return duration;
+      duration = +_;
+      return zoom;
+    };
+    zoom.x = function(z) {
+      if (!arguments.length) return x1;
+      x1 = z;
+      x0 = z.copy();
+      view = {
+        x: 0,
+        y: 0,
+        k: 1
+      };
+      return zoom;
+    };
+    zoom.y = function(z) {
+      if (!arguments.length) return y1;
+      y1 = z;
+      y0 = z.copy();
+      view = {
+        x: 0,
+        y: 0,
+        k: 1
+      };
+      return zoom;
+    };
+    function location(p) {
+      return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];
+    }
+    function point(l) {
+      return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];
+    }
+    function scaleTo(s) {
+      view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
+    }
+    function translateTo(p, l) {
+      l = point(l);
+      view.x += p[0] - l[0];
+      view.y += p[1] - l[1];
+    }
+    function zoomTo(that, p, l, k) {
+      that.__chart__ = {
+        x: view.x,
+        y: view.y,
+        k: view.k
+      };
+      scaleTo(Math.pow(2, k));
+      translateTo(center0 = p, l);
+      that = d3.select(that);
+      if (duration > 0) that = that.transition().duration(duration);
+      that.call(zoom.event);
+    }
+    function rescale() {
+      if (x1) x1.domain(x0.range().map(function(x) {
+        return (x - view.x) / view.k;
+      }).map(x0.invert));
+      if (y1) y1.domain(y0.range().map(function(y) {
+        return (y - view.y) / view.k;
+      }).map(y0.invert));
+    }
+    function zoomstarted(dispatch) {
+      if (!zooming++) dispatch({
+        type: "zoomstart"
+      });
+    }
+    function zoomed(dispatch) {
+      rescale();
+      dispatch({
+        type: "zoom",
+        scale: view.k,
+        translate: [ view.x, view.y ]
+      });
+    }
+    function zoomended(dispatch) {
+      if (!--zooming) dispatch({
+        type: "zoomend"
+      }), center0 = null;
+    }
+    function mousedowned() {
+      var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that);
+      d3_selection_interrupt.call(that);
+      zoomstarted(dispatch);
+      function moved() {
+        dragged = 1;
+        translateTo(d3.mouse(that), location0);
+        zoomed(dispatch);
+      }
+      function ended() {
+        subject.on(mousemove, null).on(mouseup, null);
+        dragRestore(dragged);
+        zoomended(dispatch);
+      }
+    }
+    function touchstarted() {
+      var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);
+      started();
+      zoomstarted(dispatch);
+      subject.on(mousedown, null).on(touchstart, started);
+      function relocate() {
+        var touches = d3.touches(that);
+        scale0 = view.k;
+        touches.forEach(function(t) {
+          if (t.identifier in locations0) locations0[t.identifier] = location(t);
+        });
+        return touches;
+      }
+      function started() {
+        var target = d3.event.target;
+        d3.select(target).on(touchmove, moved).on(touchend, ended);
+        targets.push(target);
+        var changed = d3.event.changedTouches;
+        for (var i = 0, n = changed.length; i < n; ++i) {
+          locations0[changed[i].identifier] = null;
+        }
+        var touches = relocate(), now = Date.now();
+        if (touches.length === 1) {
+          if (now - touchtime < 500) {
+            var p = touches[0];
+            zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
+            d3_eventPreventDefault();
+          }
+          touchtime = now;
+        } else if (touches.length > 1) {
+          var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];
+          distance0 = dx * dx + dy * dy;
+        }
+      }
+      function moved() {
+        var touches = d3.touches(that), p0, l0, p1, l1;
+        d3_selection_interrupt.call(that);
+        for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
+          p1 = touches[i];
+          if (l1 = locations0[p1.identifier]) {
+            if (l0) break;
+            p0 = p1, l0 = l1;
+          }
+        }
+        if (l1) {
+          var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
+          p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
+          l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
+          scaleTo(scale1 * scale0);
+        }
+        touchtime = null;
+        translateTo(p0, l0);
+        zoomed(dispatch);
+      }
+      function ended() {
+        if (d3.event.touches.length) {
+          var changed = d3.event.changedTouches;
+          for (var i = 0, n = changed.length; i < n; ++i) {
+            delete locations0[changed[i].identifier];
+          }
+          for (var identifier in locations0) {
+            return void relocate();
+          }
+        }
+        d3.selectAll(targets).on(zoomName, null);
+        subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
+        dragRestore();
+        zoomended(dispatch);
+      }
+    }
+    function mousewheeled() {
+      var dispatch = event.of(this, arguments);
+      if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), 
+      translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
+      mousewheelTimer = setTimeout(function() {
+        mousewheelTimer = null;
+        zoomended(dispatch);
+      }, 50);
+      d3_eventPreventDefault();
+      scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
+      translateTo(center0, translate0);
+      zoomed(dispatch);
+    }
+    function dblclicked() {
+      var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2;
+      zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
+    }
+    return d3.rebind(zoom, event, "on");
+  };
+  var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel;
+  d3.color = d3_color;
+  function d3_color() {}
+  d3_color.prototype.toString = function() {
+    return this.rgb() + "";
+  };
+  d3.hsl = d3_hsl;
+  function d3_hsl(h, s, l) {
+    return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l);
+  }
+  var d3_hslPrototype = d3_hsl.prototype = new d3_color();
+  d3_hslPrototype.brighter = function(k) {
+    k = Math.pow(.7, arguments.length ? k : 1);
+    return new d3_hsl(this.h, this.s, this.l / k);
+  };
+  d3_hslPrototype.darker = function(k) {
+    k = Math.pow(.7, arguments.length ? k : 1);
+    return new d3_hsl(this.h, this.s, k * this.l);
+  };
+  d3_hslPrototype.rgb = function() {
+    return d3_hsl_rgb(this.h, this.s, this.l);
+  };
+  function d3_hsl_rgb(h, s, l) {
+    var m1, m2;
+    h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
+    s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
+    l = l < 0 ? 0 : l > 1 ? 1 : l;
+    m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
+    m1 = 2 * l - m2;
+    function v(h) {
+      if (h > 360) h -= 360; else if (h < 0) h += 360;
+      if (h < 60) return m1 + (m2 - m1) * h / 60;
+      if (h < 180) return m2;
+      if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
+      return m1;
+    }
+    function vv(h) {
+      return Math.round(v(h) * 255);
+    }
+    return new d3_rgb(vv(h + 120), vv(h), vv(h - 120));
+  }
+  d3.hcl = d3_hcl;
+  function d3_hcl(h, c, l) {
+    return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l);
+  }
+  var d3_hclPrototype = d3_hcl.prototype = new d3_color();
+  d3_hclPrototype.brighter = function(k) {
+    return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
+  };
+  d3_hclPrototype.darker = function(k) {
+    return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
+  };
+  d3_hclPrototype.rgb = function() {
+    return d3_hcl_lab(this.h, this.c, this.l).rgb();
+  };
+  function d3_hcl_lab(h, c, l) {
+    if (isNaN(h)) h = 0;
+    if (isNaN(c)) c = 0;
+    return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
+  }
+  d3.lab = d3_lab;
+  function d3_lab(l, a, b) {
+    return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b);
+  }
+  var d3_lab_K = 18;
+  var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
+  var d3_labPrototype = d3_lab.prototype = new d3_color();
+  d3_labPrototype.brighter = function(k) {
+    return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+  };
+  d3_labPrototype.darker = function(k) {
+    return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+  };
+  d3_labPrototype.rgb = function() {
+    return d3_lab_rgb(this.l, this.a, this.b);
+  };
+  function d3_lab_rgb(l, a, b) {
+    var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
+    x = d3_lab_xyz(x) * d3_lab_X;
+    y = d3_lab_xyz(y) * d3_lab_Y;
+    z = d3_lab_xyz(z) * d3_lab_Z;
+    return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));
+  }
+  function d3_lab_hcl(l, a, b) {
+    return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l);
+  }
+  function d3_lab_xyz(x) {
+    return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
+  }
+  function d3_xyz_lab(x) {
+    return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+  }
+  function d3_xyz_rgb(r) {
+    return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
+  }
+  d3.rgb = d3_rgb;
+  function d3_rgb(r, g, b) {
+    return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b);
+  }
+  function d3_rgbNumber(value) {
+    return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
+  }
+  function d3_rgbString(value) {
+    return d3_rgbNumber(value) + "";
+  }
+  var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
+  d3_rgbPrototype.brighter = function(k) {
+    k = Math.pow(.7, arguments.length ? k : 1);
+    var r = this.r, g = this.g, b = this.b, i = 30;
+    if (!r && !g && !b) return new d3_rgb(i, i, i);
+    if (r && r < i) r = i;
+    if (g && g < i) g = i;
+    if (b && b < i) b = i;
+    return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k));
+  };
+  d3_rgbPrototype.darker = function(k) {
+    k = Math.pow(.7, arguments.length ? k : 1);
+    return new d3_rgb(k * this.r, k * this.g, k * this.b);
+  };
+  d3_rgbPrototype.hsl = function() {
+    return d3_rgb_hsl(this.r, this.g, this.b);
+  };
+  d3_rgbPrototype.toString = function() {
+    return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
+  };
+  function d3_rgb_hex(v) {
+    return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
+  }
+  function d3_rgb_parse(format, rgb, hsl) {
+    var r = 0, g = 0, b = 0, m1, m2, color;
+    m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase());
+    if (m1) {
+      m2 = m1[2].split(",");
+      switch (m1[1]) {
+       case "hsl":
+        {
+          return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
+        }
+
+       case "rgb":
+        {
+          return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
+        }
+      }
+    }
+    if (color = d3_rgb_names.get(format)) {
+      return rgb(color.r, color.g, color.b);
+    }
+    if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) {
+      if (format.length === 4) {
+        r = (color & 3840) >> 4;
+        r = r >> 4 | r;
+        g = color & 240;
+        g = g >> 4 | g;
+        b = color & 15;
+        b = b << 4 | b;
+      } else if (format.length === 7) {
+        r = (color & 16711680) >> 16;
+        g = (color & 65280) >> 8;
+        b = color & 255;
+      }
+    }
+    return rgb(r, g, b);
+  }
+  function d3_rgb_hsl(r, g, b) {
+    var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;
+    if (d) {
+      s = l < .5 ? d / (max + min) : d / (2 - max - min);
+      if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;
+      h *= 60;
+    } else {
+      h = NaN;
+      s = l > 0 && l < 1 ? 0 : h;
+    }
+    return new d3_hsl(h, s, l);
+  }
+  function d3_rgb_lab(r, g, b) {
+    r = d3_rgb_xyz(r);
+    g = d3_rgb_xyz(g);
+    b = d3_rgb_xyz(b);
+    var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);
+    return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
+  }
+  function d3_rgb_xyz(r) {
+    return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
+  }
+  function d3_rgb_parseNumber(c) {
+    var f = parseFloat(c);
+    return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
+  }
+  var d3_rgb_names = d3.map({
+    aliceblue: 15792383,
+    antiquewhite: 16444375,
+    aqua: 65535,
+    aquamarine: 8388564,
+    azure: 15794175,
+    beige: 16119260,
+    bisque: 16770244,
+    black: 0,
+    blanchedalmond: 16772045,
+    blue: 255,
+    blueviolet: 9055202,
+    brown: 10824234,
+    burlywood: 14596231,
+    cadetblue: 6266528,
+    chartreuse: 8388352,
+    chocolate: 13789470,
+    coral: 16744272,
+    cornflowerblue: 6591981,
+    cornsilk: 16775388,
+    crimson: 14423100,
+    cyan: 65535,
+    darkblue: 139,
+    darkcyan: 35723,
+    darkgoldenrod: 12092939,
+    darkgray: 11119017,
+    darkgreen: 25600,
+    darkgrey: 11119017,
+    darkkhaki: 12433259,
+    darkmagenta: 9109643,
+    darkolivegreen: 5597999,
+    darkorange: 16747520,
+    darkorchid: 10040012,
+    darkred: 9109504,
+    darksalmon: 15308410,
+    darkseagreen: 9419919,
+    darkslateblue: 4734347,
+    darkslategray: 3100495,
+    darkslategrey: 3100495,
+    darkturquoise: 52945,
+    darkviolet: 9699539,
+    deeppink: 16716947,
+    deepskyblue: 49151,
+    dimgray: 6908265,
+    dimgrey: 6908265,
+    dodgerblue: 2003199,
+    firebrick: 11674146,
+    floralwhite: 16775920,
+    forestgreen: 2263842,
+    fuchsia: 16711935,
+    gainsboro: 14474460,
+    ghostwhite: 16316671,
+    gold: 16766720,
+    goldenrod: 14329120,
+    gray: 8421504,
+    green: 32768,
+    greenyellow: 11403055,
+    grey: 8421504,
+    honeydew: 15794160,
+    hotpink: 16738740,
+    indianred: 13458524,
+    indigo: 4915330,
+    ivory: 16777200,
+    khaki: 15787660,
+    lavender: 15132410,
+    lavenderblush: 16773365,
+    lawngreen: 8190976,
+    lemonchiffon: 16775885,
+    lightblue: 11393254,
+    lightcoral: 15761536,
+    lightcyan: 14745599,
+    lightgoldenrodyellow: 16448210,
+    lightgray: 13882323,
+    lightgreen: 9498256,
+    lightgrey: 13882323,
+    lightpink: 16758465,
+    lightsalmon: 16752762,
+    lightseagreen: 2142890,
+    lightskyblue: 8900346,
+    lightslategray: 7833753,
+    lightslategrey: 7833753,
+    lightsteelblue: 11584734,
+    lightyellow: 16777184,
+    lime: 65280,
+    limegreen: 3329330,
+    linen: 16445670,
+    magenta: 16711935,
+    maroon: 8388608,
+    mediumaquamarine: 6737322,
+    mediumblue: 205,
+    mediumorchid: 12211667,
+    mediumpurple: 9662683,
+    mediumseagreen: 3978097,
+    mediumslateblue: 8087790,
+    mediumspringgreen: 64154,
+    mediumturquoise: 4772300,
+    mediumvioletred: 13047173,
+    midnightblue: 1644912,
+    mintcream: 16121850,
+    mistyrose: 16770273,
+    moccasin: 16770229,
+    navajowhite: 16768685,
+    navy: 128,
+    oldlace: 16643558,
+    olive: 8421376,
+    olivedrab: 7048739,
+    orange: 16753920,
+    orangered: 16729344,
+    orchid: 14315734,
+    palegoldenrod: 15657130,
+    palegreen: 10025880,
+    paleturquoise: 11529966,
+    palevioletred: 14381203,
+    papayawhip: 16773077,
+    peachpuff: 16767673,
+    peru: 13468991,
+    pink: 16761035,
+    plum: 14524637,
+    powderblue: 11591910,
+    purple: 8388736,
+    rebeccapurple: 6697881,
+    red: 16711680,
+    rosybrown: 12357519,
+    royalblue: 4286945,
+    saddlebrown: 9127187,
+    salmon: 16416882,
+    sandybrown: 16032864,
+    seagreen: 3050327,
+    seashell: 16774638,
+    sienna: 10506797,
+    silver: 12632256,
+    skyblue: 8900331,
+    slateblue: 6970061,
+    slategray: 7372944,
+    slategrey: 7372944,
+    snow: 16775930,
+    springgreen: 65407,
+    steelblue: 4620980,
+    tan: 13808780,
+    teal: 32896,
+    thistle: 14204888,
+    tomato: 16737095,
+    turquoise: 4251856,
+    violet: 15631086,
+    wheat: 16113331,
+    white: 16777215,
+    whitesmoke: 16119285,
+    yellow: 16776960,
+    yellowgreen: 10145074
+  });
+  d3_rgb_names.forEach(function(key, value) {
+    d3_rgb_names.set(key, d3_rgbNumber(value));
+  });
+  function d3_functor(v) {
+    return typeof v === "function" ? v : function() {
+      return v;
+    };
+  }
+  d3.functor = d3_functor;
+  d3.xhr = d3_xhrType(d3_identity);
+  function d3_xhrType(response) {
+    return function(url, mimeType, callback) {
+      if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, 
+      mimeType = null;
+      return d3_xhr(url, mimeType, response, callback);
+    };
+  }
+  function d3_xhr(url, mimeType, response, callback) {
+    var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
+    if (this.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
+    "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
+      request.readyState > 3 && respond();
+    };
+    function respond() {
+      var status = request.status, result;
+      if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
+        try {
+          result = response.call(xhr, request);
+        } catch (e) {
+          dispatch.error.call(xhr, e);
+          return;
+        }
+        dispatch.load.call(xhr, result);
+      } else {
+        dispatch.error.call(xhr, request);
+      }
+    }
+    request.onprogress = function(event) {
+      var o = d3.event;
+      d3.event = event;
+      try {
+        dispatch.progress.call(xhr, request);
+      } finally {
+        d3.event = o;
+      }
+    };
+    xhr.header = function(name, value) {
+      name = (name + "").toLowerCase();
+      if (arguments.length < 2) return headers[name];
+      if (value == null) delete headers[name]; else headers[name] = value + "";
+      return xhr;
+    };
+    xhr.mimeType = function(value) {
+      if (!arguments.length) return mimeType;
+      mimeType = value == null ? null : value + "";
+      return xhr;
+    };
+    xhr.responseType = function(value) {
+      if (!arguments.length) return responseType;
+      responseType = value;
+      return xhr;
+    };
+    xhr.response = function(value) {
+      response = value;
+      return xhr;
+    };
+    [ "get", "post" ].forEach(function(method) {
+      xhr[method] = function() {
+        return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
+      };
+    });
+    xhr.send = function(method, data, callback) {
+      if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
+      request.open(method, url, true);
+      if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
+      if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
+      if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
+      if (responseType != null) request.responseType = responseType;
+      if (callback != null) xhr.on("error", callback).on("load", function(request) {
+        callback(null, request);
+      });
+      dispatch.beforesend.call(xhr, request);
+      request.send(data == null ? null : data);
+      return xhr;
+    };
+    xhr.abort = function() {
+      request.abort();
+      return xhr;
+    };
+    d3.rebind(xhr, dispatch, "on");
+    return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
+  }
+  function d3_xhr_fixCallback(callback) {
+    return callback.length === 1 ? function(error, request) {
+      callback(error == null ? request : null);
+    } : callback;
+  }
+  function d3_xhrHasResponse(request) {
+    var type = request.responseType;
+    return type && type !== "text" ? request.response : request.responseText;
+  }
+  d3.dsv = function(delimiter, mimeType) {
+    var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
+    function dsv(url, row, callback) {
+      if (arguments.length < 3) callback = row, row = null;
+      var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
+      xhr.row = function(_) {
+        return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
+      };
+      return xhr;
+    }
+    function response(request) {
+      return dsv.parse(request.responseText);
+    }
+    function typedResponse(f) {
+      return function(request) {
+        return dsv.parse(request.responseText, f);
+      };
+    }
+    dsv.parse = function(text, f) {
+      var o;
+      return dsv.parseRows(text, function(row, i) {
+        if (o) return o(row, i - 1);
+        var a = new Function("d", "return {" + row.map(function(name, i) {
+          return JSON.stringify(name) + ": d[" + i + "]";
+        }).join(",") + "}");
+        o = f ? function(row, i) {
+          return f(a(row), i);
+        } : a;
+      });
+    };
+    dsv.parseRows = function(text, f) {
+      var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
+      function token() {
+        if (I >= N) return EOF;
+        if (eol) return eol = false, EOL;
+        var j = I;
+        if (text.charCodeAt(j) === 34) {
+          var i = j;
+          while (i++ < N) {
+            if (text.charCodeAt(i) === 34) {
+              if (text.charCodeAt(i + 1) !== 34) break;
+              ++i;
+            }
+          }
+          I = i + 2;
+          var c = text.charCodeAt(i + 1);
+          if (c === 13) {
+            eol = true;
+            if (text.charCodeAt(i + 2) === 10) ++I;
+          } else if (c === 10) {
+            eol = true;
+          }
+          return text.slice(j + 1, i).replace(/""/g, '"');
+        }
+        while (I < N) {
+          var c = text.charCodeAt(I++), k = 1;
+          if (c === 10) eol = true; else if (c === 13) {
+            eol = true;
+            if (text.charCodeAt(I) === 10) ++I, ++k;
+          } else if (c !== delimiterCode) continue;
+          return text.slice(j, I - k);
+        }
+        return text.slice(j);
+      }
+      while ((t = token()) !== EOF) {
+        var a = [];
+        while (t !== EOL && t !== EOF) {
+          a.push(t);
+          t = token();
+        }
+        if (f && (a = f(a, n++)) == null) continue;
+        rows.push(a);
+      }
+      return rows;
+    };
+    dsv.format = function(rows) {
+      if (Array.isArray(rows[0])) return dsv.formatRows(rows);
+      var fieldSet = new d3_Set(), fields = [];
+      rows.forEach(function(row) {
+        for (var field in row) {
+          if (!fieldSet.has(field)) {
+            fields.push(fieldSet.add(field));
+          }
+        }
+      });
+      return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
+        return fields.map(function(field) {
+          return formatValue(row[field]);
+        }).join(delimiter);
+      })).join("\n");
+    };
+    dsv.formatRows = function(rows) {
+      return rows.map(formatRow).join("\n");
+    };
+    function formatRow(row) {
+      return row.map(formatValue).join(delimiter);
+    }
+    function formatValue(text) {
+      return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
+    }
+    return dsv;
+  };
+  d3.csv = d3.dsv(",", "text/csv");
+  d3.tsv = d3.dsv("	", "text/tab-separated-values");
+  var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) {
+    setTimeout(callback, 17);
+  };
+  d3.timer = function() {
+    d3_timer.apply(this, arguments);
+  };
+  function d3_timer(callback, delay, then) {
+    var n = arguments.length;
+    if (n < 2) delay = 0;
+    if (n < 3) then = Date.now();
+    var time = then + delay, timer = {
+      c: callback,
+      t: time,
+      n: null
+    };
+    if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;
+    d3_timer_queueTail = timer;
+    if (!d3_timer_interval) {
+      d3_timer_timeout = clearTimeout(d3_timer_timeout);
+      d3_timer_interval = 1;
+      d3_timer_frame(d3_timer_step);
+    }
+    return timer;
+  }
+  function d3_timer_step() {
+    var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
+    if (delay > 24) {
+      if (isFinite(delay)) {
+        clearTimeout(d3_timer_timeout);
+        d3_timer_timeout = setTimeout(d3_timer_step, delay);
+      }
+      d3_timer_interval = 0;
+    } else {
+      d3_timer_interval = 1;
+      d3_timer_frame(d3_timer_step);
+    }
+  }
+  d3.timer.flush = function() {
+    d3_timer_mark();
+    d3_timer_sweep();
+  };
+  function d3_timer_mark() {
+    var now = Date.now(), timer = d3_timer_queueHead;
+    while (timer) {
+      if (now >= timer.t && timer.c(now - timer.t)) timer.c = null;
+      timer = timer.n;
+    }
+    return now;
+  }
+  function d3_timer_sweep() {
+    var t0, t1 = d3_timer_queueHead, time = Infinity;
+    while (t1) {
+      if (t1.c) {
+        if (t1.t < time) time = t1.t;
+        t1 = (t0 = t1).n;
+      } else {
+        t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
+      }
+    }
+    d3_timer_queueTail = t0;
+    return time;
+  }
+  function d3_format_precision(x, p) {
+    return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
+  }
+  d3.round = function(x, n) {
+    return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
+  };
+  var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
+  d3.formatPrefix = function(value, precision) {
+    var i = 0;
+    if (value = +value) {
+      if (value < 0) value *= -1;
+      if (precision) value = d3.round(value, d3_format_precision(value, precision));
+      i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
+      i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
+    }
+    return d3_formatPrefixes[8 + i / 3];
+  };
+  function d3_formatPrefix(d, i) {
+    var k = Math.pow(10, abs(8 - i) * 3);
+    return {
+      scale: i > 8 ? function(d) {
+        return d / k;
+      } : function(d) {
+        return d * k;
+      },
+      symbol: d
+    };
+  }
+  function d3_locale_numberFormat(locale) {
+    var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping && locale_thousands ? function(value, width) {
+      var i = value.length, t = [], j = 0, g = locale_grouping[0], length = 0;
+      while (i > 0 && g > 0) {
+        if (length + g + 1 > width) g = Math.max(1, width - length);
+        t.push(value.substring(i -= g, i + g));
+        if ((length += g + 1) > width) break;
+        g = locale_grouping[j = (j + 1) % locale_grouping.length];
+      }
+      return t.reverse().join(locale_thousands);
+    } : d3_identity;
+    return function(specifier) {
+      var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "-", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false, exponent = true;
+      if (precision) precision = +precision.substring(1);
+      if (zfill || fill === "0" && align === "=") {
+        zfill = fill = "0";
+        align = "=";
+      }
+      switch (type) {
+       case "n":
+        comma = true;
+        type = "g";
+        break;
+
+       case "%":
+        scale = 100;
+        suffix = "%";
+        type = "f";
+        break;
+
+       case "p":
+        scale = 100;
+        suffix = "%";
+        type = "r";
+        break;
+
+       case "b":
+       case "o":
+       case "x":
+       case "X":
+        if (symbol === "#") prefix = "0" + type.toLowerCase();
+
+       case "c":
+        exponent = false;
+
+       case "d":
+        integer = true;
+        precision = 0;
+        break;
+
+       case "s":
+        scale = -1;
+        type = "r";
+        break;
+      }
+      if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];
+      if (type == "r" && !precision) type = "g";
+      if (precision != null) {
+        if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));
+      }
+      type = d3_format_types.get(type) || d3_format_typeDefault;
+      var zcomma = zfill && comma;
+      return function(value) {
+        var fullSuffix = suffix;
+        if (integer && value % 1) return "";
+        var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign === "-" ? "" : sign;
+        if (scale < 0) {
+          var unit = d3.formatPrefix(value, precision);
+          value = unit.scale(value);
+          fullSuffix = unit.symbol + suffix;
+        } else {
+          value *= scale;
+        }
+        value = type(value, precision);
+        var i = value.lastIndexOf("."), before, after;
+        if (i < 0) {
+          var j = exponent ? value.lastIndexOf("e") : -1;
+          if (j < 0) before = value, after = ""; else before = value.substring(0, j), after = value.substring(j);
+        } else {
+          before = value.substring(0, i);
+          after = locale_decimal + value.substring(i + 1);
+        }
+        if (!zfill && comma) before = formatGroup(before, Infinity);
+        var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
+        if (zcomma) before = formatGroup(padding + before, padding.length ? width - after.length : Infinity);
+        negative += prefix;
+        value = before + after;
+        return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;
+      };
+    };
+  }
+  var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
+  var d3_format_types = d3.map({
+    b: function(x) {
+      return x.toString(2);
+    },
+    c: function(x) {
+      return String.fromCharCode(x);
+    },
+    o: function(x) {
+      return x.toString(8);
+    },
+    x: function(x) {
+      return x.toString(16);
+    },
+    X: function(x) {
+      return x.toString(16).toUpperCase();
+    },
+    g: function(x, p) {
+      return x.toPrecision(p);
+    },
+    e: function(x, p) {
+      return x.toExponential(p);
+    },
+    f: function(x, p) {
+      return x.toFixed(p);
+    },
+    r: function(x, p) {
+      return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));
+    }
+  });
+  function d3_format_typeDefault(x) {
+    return x + "";
+  }
+  var d3_time = d3.time = {}, d3_date = Date;
+  function d3_date_utc() {
+    this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
+  }
+  d3_date_utc.prototype = {
+    getDate: function() {
+      return this._.getUTCDate();
+    },
+    getDay: function() {
+      return this._.getUTCDay();
+    },
+    getFullYear: function() {
+      return this._.getUTCFullYear();
+    },
+    getHours: function() {
+      return this._.getUTCHours();
+    },
+    getMilliseconds: function() {
+      return this._.getUTCMilliseconds();
+    },
+    getMinutes: function() {
+      return this._.getUTCMinutes();
+    },
+    getMonth: function() {
+      return this._.getUTCMonth();
+    },
+    getSeconds: function() {
+      return this._.getUTCSeconds();
+    },
+    getTime: function() {
+      return this._.getTime();
+    },
+    getTimezoneOffset: function() {
+      return 0;
+    },
+    valueOf: function() {
+      return this._.valueOf();
+    },
+    setDate: function() {
+      d3_time_prototype.setUTCDate.apply(this._, arguments);
+    },
+    setDay: function() {
+      d3_time_prototype.setUTCDay.apply(this._, arguments);
+    },
+    setFullYear: function() {
+      d3_time_prototype.setUTCFullYear.apply(this._, arguments);
+    },
+    setHours: function() {
+      d3_time_prototype.setUTCHours.apply(this._, arguments);
+    },
+    setMilliseconds: function() {
+      d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);
+    },
+    setMinutes: function() {
+      d3_time_prototype.setUTCMinutes.apply(this._, arguments);
+    },
+    setMonth: function() {
+      d3_time_prototype.setUTCMonth.apply(this._, arguments);
+    },
+    setSeconds: function() {
+      d3_time_prototype.setUTCSeconds.apply(this._, arguments);
+    },
+    setTime: function() {
+      d3_time_prototype.setTime.apply(this._, arguments);
+    }
+  };
+  var d3_time_prototype = Date.prototype;
+  function d3_time_interval(local, step, number) {
+    function round(date) {
+      var d0 = local(date), d1 = offset(d0, 1);
+      return date - d0 < d1 - date ? d0 : d1;
+    }
+    function ceil(date) {
+      step(date = local(new d3_date(date - 1)), 1);
+      return date;
+    }
+    function offset(date, k) {
+      step(date = new d3_date(+date), k);
+      return date;
+    }
+    function range(t0, t1, dt) {
+      var time = ceil(t0), times = [];
+      if (dt > 1) {
+        while (time < t1) {
+          if (!(number(time) % dt)) times.push(new Date(+time));
+          step(time, 1);
+        }
+      } else {
+        while (time < t1) times.push(new Date(+time)), step(time, 1);
+      }
+      return times;
+    }
+    function range_utc(t0, t1, dt) {
+      try {
+        d3_date = d3_date_utc;
+        var utc = new d3_date_utc();
+        utc._ = t0;
+        return range(utc, t1, dt);
+      } finally {
+        d3_date = Date;
+      }
+    }
+    local.floor = local;
+    local.round = round;
+    local.ceil = ceil;
+    local.offset = offset;
+    local.range = range;
+    var utc = local.utc = d3_time_interval_utc(local);
+    utc.floor = utc;
+    utc.round = d3_time_interval_utc(round);
+    utc.ceil = d3_time_interval_utc(ceil);
+    utc.offset = d3_time_interval_utc(offset);
+    utc.range = range_utc;
+    return local;
+  }
+  function d3_time_interval_utc(method) {
+    return function(date, k) {
+      try {
+        d3_date = d3_date_utc;
+        var utc = new d3_date_utc();
+        utc._ = date;
+        return method(utc, k)._;
+      } finally {
+        d3_date = Date;
+      }
+    };
+  }
+  d3_time.year = d3_time_interval(function(date) {
+    date = d3_time.day(date);
+    date.setMonth(0, 1);
+    return date;
+  }, function(date, offset) {
+    date.setFullYear(date.getFullYear() + offset);
+  }, function(date) {
+    return date.getFullYear();
+  });
+  d3_time.years = d3_time.year.range;
+  d3_time.years.utc = d3_time.year.utc.range;
+  d3_time.day = d3_time_interval(function(date) {
+    var day = new d3_date(2e3, 0);
+    day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+    return day;
+  }, function(date, offset) {
+    date.setDate(date.getDate() + offset);
+  }, function(date) {
+    return date.getDate() - 1;
+  });
+  d3_time.days = d3_time.day.range;
+  d3_time.days.utc = d3_time.day.utc.range;
+  d3_time.dayOfYear = function(date) {
+    var year = d3_time.year(date);
+    return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);
+  };
+  [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {
+    i = 7 - i;
+    var interval = d3_time[day] = d3_time_interval(function(date) {
+      (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
+      return date;
+    }, function(date, offset) {
+      date.setDate(date.getDate() + Math.floor(offset) * 7);
+    }, function(date) {
+      var day = d3_time.year(date).getDay();
+      return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
+    });
+    d3_time[day + "s"] = interval.range;
+    d3_time[day + "s"].utc = interval.utc.range;
+    d3_time[day + "OfYear"] = function(date) {
+      var day = d3_time.year(date).getDay();
+      return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);
+    };
+  });
+  d3_time.week = d3_time.sunday;
+  d3_time.weeks = d3_time.sunday.range;
+  d3_time.weeks.utc = d3_time.sunday.utc.range;
+  d3_time.weekOfYear = d3_time.sundayOfYear;
+  function d3_locale_timeFormat(locale) {
+    var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
+    function d3_time_format(template) {
+      var n = template.length;
+      function format(date) {
+        var string = [], i = -1, j = 0, c, p, f;
+        while (++i < n) {
+          if (template.charCodeAt(i) === 37) {
+            string.push(template.slice(j, i));
+            if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);
+            if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);
+            string.push(c);
+            j = i + 1;
+          }
+        }
+        string.push(template.slice(j, i));
+        return string.join("");
+      }
+      format.parse = function(string) {
+        var d = {
+          y: 1900,
+          m: 0,
+          d: 1,
+          H: 0,
+          M: 0,
+          S: 0,
+          L: 0,
+          Z: null
+        }, i = d3_time_parse(d, template, string, 0);
+        if (i != string.length) return null;
+        if ("p" in d) d.H = d.H % 12 + d.p * 12;
+        var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();
+        if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("W" in d || "U" in d) {
+          if (!("w" in d)) d.w = "W" in d ? 1 : 0;
+          date.setFullYear(d.y, 0, 1);
+          date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);
+        } else date.setFullYear(d.y, d.m, d.d);
+        date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L);
+        return localZ ? date._ : date;
+      };
+      format.toString = function() {
+        return template;
+      };
+      return format;
+    }
+    function d3_time_parse(date, template, string, j) {
+      var c, p, t, i = 0, n = template.length, m = string.length;
+      while (i < n) {
+        if (j >= m) return -1;
+        c = template.charCodeAt(i++);
+        if (c === 37) {
+          t = template.charAt(i++);
+          p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];
+          if (!p || (j = p(date, string, j)) < 0) return -1;
+        } else if (c != string.charCodeAt(j++)) {
+          return -1;
+        }
+      }
+      return j;
+    }
+    d3_time_format.utc = function(template) {
+      var local = d3_time_format(template);
+      function format(date) {
+        try {
+          d3_date = d3_date_utc;
+          var utc = new d3_date();
+          utc._ = date;
+          return local(utc);
+        } finally {
+          d3_date = Date;
+        }
+      }
+      format.parse = function(string) {
+        try {
+          d3_date = d3_date_utc;
+          var date = local.parse(string);
+          return date && date._;
+        } finally {
+          d3_date = Date;
+        }
+      };
+      format.toString = local.toString;
+      return format;
+    };
+    d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;
+    var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths);
+    locale_periods.forEach(function(p, i) {
+      d3_time_periodLookup.set(p.toLowerCase(), i);
+    });
+    var d3_time_formats = {
+      a: function(d) {
+        return locale_shortDays[d.getDay()];
+      },
+      A: function(d) {
+        return locale_days[d.getDay()];
+      },
+      b: function(d) {
+        return locale_shortMonths[d.getMonth()];
+      },
+      B: function(d) {
+        return locale_months[d.getMonth()];
+      },
+      c: d3_time_format(locale_dateTime),
+      d: function(d, p) {
+        return d3_time_formatPad(d.getDate(), p, 2);
+      },
+      e: function(d, p) {
+        return d3_time_formatPad(d.getDate(), p, 2);
+      },
+      H: function(d, p) {
+        return d3_time_formatPad(d.getHours(), p, 2);
+      },
+      I: function(d, p) {
+        return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);
+      },
+      j: function(d, p) {
+        return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);
+      },
+      L: function(d, p) {
+        return d3_time_formatPad(d.getMilliseconds(), p, 3);
+      },
+      m: function(d, p) {
+        return d3_time_formatPad(d.getMonth() + 1, p, 2);
+      },
+      M: function(d, p) {
+        return d3_time_formatPad(d.getMinutes(), p, 2);
+      },
+      p: function(d) {
+        return locale_periods[+(d.getHours() >= 12)];
+      },
+      S: function(d, p) {
+        return d3_time_formatPad(d.getSeconds(), p, 2);
+      },
+      U: function(d, p) {
+        return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);
+      },
+      w: function(d) {
+        return d.getDay();
+      },
+      W: function(d, p) {
+        return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);
+      },
+      x: d3_time_format(locale_date),
+      X: d3_time_format(locale_time),
+      y: function(d, p) {
+        return d3_time_formatPad(d.getFullYear() % 100, p, 2);
+      },
+      Y: function(d, p) {
+        return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);
+      },
+      Z: d3_time_zone,
+      "%": function() {
+        return "%";
+      }
+    };
+    var d3_time_parsers = {
+      a: d3_time_parseWeekdayAbbrev,
+      A: d3_time_parseWeekday,
+      b: d3_time_parseMonthAbbrev,
+      B: d3_time_parseMonth,
+      c: d3_time_parseLocaleFull,
+      d: d3_time_parseDay,
+      e: d3_time_parseDay,
+      H: d3_time_parseHour24,
+      I: d3_time_parseHour24,
+      j: d3_time_parseDayOfYear,
+      L: d3_time_parseMilliseconds,
+      m: d3_time_parseMonthNumber,
+      M: d3_time_parseMinutes,
+      p: d3_time_parseAmPm,
+      S: d3_time_parseSeconds,
+      U: d3_time_parseWeekNumberSunday,
+      w: d3_time_parseWeekdayNumber,
+      W: d3_time_parseWeekNumberMonday,
+      x: d3_time_parseLocaleDate,
+      X: d3_time_parseLocaleTime,
+      y: d3_time_parseYear,
+      Y: d3_time_parseFullYear,
+      Z: d3_time_parseZone,
+      "%": d3_time_parseLiteralPercent
+    };
+    function d3_time_parseWeekdayAbbrev(date, string, i) {
+      d3_time_dayAbbrevRe.lastIndex = 0;
+      var n = d3_time_dayAbbrevRe.exec(string.slice(i));
+      return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+    function d3_time_parseWeekday(date, string, i) {
+      d3_time_dayRe.lastIndex = 0;
+      var n = d3_time_dayRe.exec(string.slice(i));
+      return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+    function d3_time_parseMonthAbbrev(date, string, i) {
+      d3_time_monthAbbrevRe.lastIndex = 0;
+      var n = d3_time_monthAbbrevRe.exec(string.slice(i));
+      return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+    function d3_time_parseMonth(date, string, i) {
+      d3_time_monthRe.lastIndex = 0;
+      var n = d3_time_monthRe.exec(string.slice(i));
+      return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+    function d3_time_parseLocaleFull(date, string, i) {
+      return d3_time_parse(date, d3_time_formats.c.toString(), string, i);
+    }
+    function d3_time_parseLocaleDate(date, string, i) {
+      return d3_time_parse(date, d3_time_formats.x.toString(), string, i);
+    }
+    function d3_time_parseLocaleTime(date, string, i) {
+      return d3_time_parse(date, d3_time_formats.X.toString(), string, i);
+    }
+    function d3_time_parseAmPm(date, string, i) {
+      var n = d3_time_periodLookup.get(string.slice(i, i += 2).toLowerCase());
+      return n == null ? -1 : (date.p = n, i);
+    }
+    return d3_time_format;
+  }
+  var d3_time_formatPads = {
+    "-": "",
+    _: " ",
+    "0": "0"
+  }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;
+  function d3_time_formatPad(value, fill, width) {
+    var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
+    return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+  }
+  function d3_time_formatRe(names) {
+    return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i");
+  }
+  function d3_time_formatLookup(names) {
+    var map = new d3_Map(), i = -1, n = names.length;
+    while (++i < n) map.set(names[i].toLowerCase(), i);
+    return map;
+  }
+  function d3_time_parseWeekdayNumber(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 1));
+    return n ? (date.w = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseWeekNumberSunday(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i));
+    return n ? (date.U = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseWeekNumberMonday(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i));
+    return n ? (date.W = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseFullYear(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 4));
+    return n ? (date.y = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseYear(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1;
+  }
+  function d3_time_parseZone(date, string, i) {
+    return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5)) ? (date.Z = -string, 
+    i + 5) : -1;
+  }
+  function d3_time_expandYear(d) {
+    return d + (d > 68 ? 1900 : 2e3);
+  }
+  function d3_time_parseMonthNumber(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.m = n[0] - 1, i + n[0].length) : -1;
+  }
+  function d3_time_parseDay(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.d = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseDayOfYear(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+    return n ? (date.j = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseHour24(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.H = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseMinutes(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.M = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseSeconds(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+    return n ? (date.S = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_parseMilliseconds(date, string, i) {
+    d3_time_numberRe.lastIndex = 0;
+    var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+    return n ? (date.L = +n[0], i + n[0].length) : -1;
+  }
+  function d3_time_zone(d) {
+    var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = abs(z) / 60 | 0, zm = abs(z) % 60;
+    return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2);
+  }
+  function d3_time_parseLiteralPercent(date, string, i) {
+    d3_time_percentRe.lastIndex = 0;
+    var n = d3_time_percentRe.exec(string.slice(i, i + 1));
+    return n ? i + n[0].length : -1;
+  }
+  function d3_time_formatMulti(formats) {
+    var n = formats.length, i = -1;
+    while (++i < n) formats[i][0] = this(formats[i][0]);
+    return function(date) {
+      var i = 0, f = formats[i];
+      while (!f[1](date)) f = formats[++i];
+      return f[0](date);
+    };
+  }
+  d3.locale = function(locale) {
+    return {
+      numberFormat: d3_locale_numberFormat(locale),
+      timeFormat: d3_locale_timeFormat(locale)
+    };
+  };
+  var d3_locale_enUS = d3.locale({
+    decimal: ".",
+    thousands: ",",
+    grouping: [ 3 ],
+    currency: [ "$", "" ],
+    dateTime: "%a %b %e %X %Y",
+    date: "%m/%d/%Y",
+    time: "%H:%M:%S",
+    periods: [ "AM", "PM" ],
+    days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
+    shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
+    months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
+    shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
+  });
+  d3.format = d3_locale_enUS.numberFormat;
+  d3.geo = {};
+  function d3_adder() {}
+  d3_adder.prototype = {
+    s: 0,
+    t: 0,
+    add: function(y) {
+      d3_adderSum(y, this.t, d3_adderTemp);
+      d3_adderSum(d3_adderTemp.s, this.s, this);
+      if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t;
+    },
+    reset: function() {
+      this.s = this.t = 0;
+    },
+    valueOf: function() {
+      return this.s;
+    }
+  };
+  var d3_adderTemp = new d3_adder();
+  function d3_adderSum(a, b, o) {
+    var x = o.s = a + b, bv = x - a, av = x - bv;
+    o.t = a - av + (b - bv);
+  }
+  d3.geo.stream = function(object, listener) {
+    if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
+      d3_geo_streamObjectType[object.type](object, listener);
+    } else {
+      d3_geo_streamGeometry(object, listener);
+    }
+  };
+  function d3_geo_streamGeometry(geometry, listener) {
+    if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
+      d3_geo_streamGeometryType[geometry.type](geometry, listener);
+    }
+  }
+  var d3_geo_streamObjectType = {
+    Feature: function(feature, listener) {
+      d3_geo_streamGeometry(feature.geometry, listener);
+    },
+    FeatureCollection: function(object, listener) {
+      var features = object.features, i = -1, n = features.length;
+      while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
+    }
+  };
+  var d3_geo_streamGeometryType = {
+    Sphere: function(object, listener) {
+      listener.sphere();
+    },
+    Point: function(object, listener) {
+      object = object.coordinates;
+      listener.point(object[0], object[1], object[2]);
+    },
+    MultiPoint: function(object, listener) {
+      var coordinates = object.coordinates, i = -1, n = coordinates.length;
+      while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
+    },
+    LineString: function(object, listener) {
+      d3_geo_streamLine(object.coordinates, listener, 0);
+    },
+    MultiLineString: function(object, listener) {
+      var coordinates = object.coordinates, i = -1, n = coordinates.length;
+      while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
+    },
+    Polygon: function(object, listener) {
+      d3_geo_streamPolygon(object.coordinates, listener);
+    },
+    MultiPolygon: function(object, listener) {
+      var coordinates = object.coordinates, i = -1, n = coordinates.length;
+      while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
+    },
+    GeometryCollection: function(object, listener) {
+      var geometries = object.geometries, i = -1, n = geometries.length;
+      while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
+    }
+  };
+  function d3_geo_streamLine(coordinates, listener, closed) {
+    var i = -1, n = coordinates.length - closed, coordinate;
+    listener.lineStart();
+    while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
+    listener.lineEnd();
+  }
+  function d3_geo_streamPolygon(coordinates, listener) {
+    var i = -1, n = coordinates.length;
+    listener.polygonStart();
+    while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
+    listener.polygonEnd();
+  }
+  d3.geo.area = function(object) {
+    d3_geo_areaSum = 0;
+    d3.geo.stream(object, d3_geo_area);
+    return d3_geo_areaSum;
+  };
+  var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder();
+  var d3_geo_area = {
+    sphere: function() {
+      d3_geo_areaSum += 4 * π;
+    },
+    point: d3_noop,
+    lineStart: d3_noop,
+    lineEnd: d3_noop,
+    polygonStart: function() {
+      d3_geo_areaRingSum.reset();
+      d3_geo_area.lineStart = d3_geo_areaRingStart;
+    },
+    polygonEnd: function() {
+      var area = 2 * d3_geo_areaRingSum;
+      d3_geo_areaSum += area < 0 ? 4 * π + area : area;
+      d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
+    }
+  };
+  function d3_geo_areaRingStart() {
+    var λ00, φ00, λ0, cosφ0, sinφ0;
+    d3_geo_area.point = function(λ, φ) {
+      d3_geo_area.point = nextPoint;
+      λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), 
+      sinφ0 = Math.sin(φ);
+    };
+    function nextPoint(λ, φ) {
+      λ *= d3_radians;
+      φ = φ * d3_radians / 2 + π / 4;
+      var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ);
+      d3_geo_areaRingSum.add(Math.atan2(v, u));
+      λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
+    }
+    d3_geo_area.lineEnd = function() {
+      nextPoint(λ00, φ00);
+    };
+  }
+  function d3_geo_cartesian(spherical) {
+    var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
+    return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
+  }
+  function d3_geo_cartesianDot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+  function d3_geo_cartesianCross(a, b) {
+    return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
+  }
+  function d3_geo_cartesianAdd(a, b) {
+    a[0] += b[0];
+    a[1] += b[1];
+    a[2] += b[2];
+  }
+  function d3_geo_cartesianScale(vector, k) {
+    return [ vector[0] * k, vector[1] * k, vector[2] * k ];
+  }
+  function d3_geo_cartesianNormalize(d) {
+    var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+    d[0] /= l;
+    d[1] /= l;
+    d[2] /= l;
+  }
+  function d3_geo_spherical(cartesian) {
+    return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ];
+  }
+  function d3_geo_sphericalEqual(a, b) {
+    return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
+  }
+  d3.geo.bounds = function() {
+    var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range;
+    var bound = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        bound.point = ringPoint;
+        bound.lineStart = ringStart;
+        bound.lineEnd = ringEnd;
+        dλSum = 0;
+        d3_geo_area.polygonStart();
+      },
+      polygonEnd: function() {
+        d3_geo_area.polygonEnd();
+        bound.point = point;
+        bound.lineStart = lineStart;
+        bound.lineEnd = lineEnd;
+        if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90;
+        range[0] = λ0, range[1] = λ1;
+      }
+    };
+    function point(λ, φ) {
+      ranges.push(range = [ λ0 = λ, λ1 = λ ]);
+      if (φ < φ0) φ0 = φ;
+      if (φ > φ1) φ1 = φ;
+    }
+    function linePoint(λ, φ) {
+      var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]);
+      if (p0) {
+        var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal);
+        d3_geo_cartesianNormalize(inflection);
+        inflection = d3_geo_spherical(inflection);
+        var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180;
+        if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+          var φi = inflection[1] * d3_degrees;
+          if (φi > φ1) φ1 = φi;
+        } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+          var φi = -inflection[1] * d3_degrees;
+          if (φi < φ0) φ0 = φi;
+        } else {
+          if (φ < φ0) φ0 = φ;
+          if (φ > φ1) φ1 = φ;
+        }
+        if (antimeridian) {
+          if (λ < λ_) {
+            if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+          } else {
+            if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+          }
+        } else {
+          if (λ1 >= λ0) {
+            if (λ < λ0) λ0 = λ;
+            if (λ > λ1) λ1 = λ;
+          } else {
+            if (λ > λ_) {
+              if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+            } else {
+              if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+            }
+          }
+        }
+      } else {
+        point(λ, φ);
+      }
+      p0 = p, λ_ = λ;
+    }
+    function lineStart() {
+      bound.point = linePoint;
+    }
+    function lineEnd() {
+      range[0] = λ0, range[1] = λ1;
+      bound.point = point;
+      p0 = null;
+    }
+    function ringPoint(λ, φ) {
+      if (p0) {
+        var dλ = λ - λ_;
+        dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
+      } else λ__ = λ, φ__ = φ;
+      d3_geo_area.point(λ, φ);
+      linePoint(λ, φ);
+    }
+    function ringStart() {
+      d3_geo_area.lineStart();
+    }
+    function ringEnd() {
+      ringPoint(λ__, φ__);
+      d3_geo_area.lineEnd();
+      if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
+      range[0] = λ0, range[1] = λ1;
+      p0 = null;
+    }
+    function angle(λ0, λ1) {
+      return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1;
+    }
+    function compareRanges(a, b) {
+      return a[0] - b[0];
+    }
+    function withinRange(x, range) {
+      return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+    }
+    return function(feature) {
+      φ1 = λ1 = -(λ0 = φ0 = Infinity);
+      ranges = [];
+      d3.geo.stream(feature, bound);
+      var n = ranges.length;
+      if (n) {
+        ranges.sort(compareRanges);
+        for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) {
+          b = ranges[i];
+          if (withinRange(b[0], a) || withinRange(b[1], a)) {
+            if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+            if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+          } else {
+            merged.push(a = b);
+          }
+        }
+        var best = -Infinity, dλ;
+        for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
+          b = merged[i];
+          if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
+        }
+      }
+      ranges = range = null;
+      return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ];
+    };
+  }();
+  d3.geo.centroid = function(object) {
+    d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+    d3.geo.stream(object, d3_geo_centroid);
+    var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z;
+    if (m < ε2) {
+      x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
+      if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
+      m = x * x + y * y + z * z;
+      if (m < ε2) return [ NaN, NaN ];
+    }
+    return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ];
+  };
+  var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2;
+  var d3_geo_centroid = {
+    sphere: d3_noop,
+    point: d3_geo_centroidPoint,
+    lineStart: d3_geo_centroidLineStart,
+    lineEnd: d3_geo_centroidLineEnd,
+    polygonStart: function() {
+      d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
+    },
+    polygonEnd: function() {
+      d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
+    }
+  };
+  function d3_geo_centroidPoint(λ, φ) {
+    λ *= d3_radians;
+    var cosφ = Math.cos(φ *= d3_radians);
+    d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
+  }
+  function d3_geo_centroidPointXYZ(x, y, z) {
+    ++d3_geo_centroidW0;
+    d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
+    d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
+    d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
+  }
+  function d3_geo_centroidLineStart() {
+    var x0, y0, z0;
+    d3_geo_centroid.point = function(λ, φ) {
+      λ *= d3_radians;
+      var cosφ = Math.cos(φ *= d3_radians);
+      x0 = cosφ * Math.cos(λ);
+      y0 = cosφ * Math.sin(λ);
+      z0 = Math.sin(φ);
+      d3_geo_centroid.point = nextPoint;
+      d3_geo_centroidPointXYZ(x0, y0, z0);
+    };
+    function nextPoint(λ, φ) {
+      λ *= d3_radians;
+      var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+      d3_geo_centroidW1 += w;
+      d3_geo_centroidX1 += w * (x0 + (x0 = x));
+      d3_geo_centroidY1 += w * (y0 + (y0 = y));
+      d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+      d3_geo_centroidPointXYZ(x0, y0, z0);
+    }
+  }
+  function d3_geo_centroidLineEnd() {
+    d3_geo_centroid.point = d3_geo_centroidPoint;
+  }
+  function d3_geo_centroidRingStart() {
+    var λ00, φ00, x0, y0, z0;
+    d3_geo_centroid.point = function(λ, φ) {
+      λ00 = λ, φ00 = φ;
+      d3_geo_centroid.point = nextPoint;
+      λ *= d3_radians;
+      var cosφ = Math.cos(φ *= d3_radians);
+      x0 = cosφ * Math.cos(λ);
+      y0 = cosφ * Math.sin(λ);
+      z0 = Math.sin(φ);
+      d3_geo_centroidPointXYZ(x0, y0, z0);
+    };
+    d3_geo_centroid.lineEnd = function() {
+      nextPoint(λ00, φ00);
+      d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
+      d3_geo_centroid.point = d3_geo_centroidPoint;
+    };
+    function nextPoint(λ, φ) {
+      λ *= d3_radians;
+      var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u);
+      d3_geo_centroidX2 += v * cx;
+      d3_geo_centroidY2 += v * cy;
+      d3_geo_centroidZ2 += v * cz;
+      d3_geo_centroidW1 += w;
+      d3_geo_centroidX1 += w * (x0 + (x0 = x));
+      d3_geo_centroidY1 += w * (y0 + (y0 = y));
+      d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+      d3_geo_centroidPointXYZ(x0, y0, z0);
+    }
+  }
+  function d3_geo_compose(a, b) {
+    function compose(x, y) {
+      return x = a(x, y), b(x[0], x[1]);
+    }
+    if (a.invert && b.invert) compose.invert = function(x, y) {
+      return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+    };
+    return compose;
+  }
+  function d3_true() {
+    return true;
+  }
+  function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
+    var subject = [], clip = [];
+    segments.forEach(function(segment) {
+      if ((n = segment.length - 1) <= 0) return;
+      var n, p0 = segment[0], p1 = segment[n];
+      if (d3_geo_sphericalEqual(p0, p1)) {
+        listener.lineStart();
+        for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
+        listener.lineEnd();
+        return;
+      }
+      var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
+      a.o = b;
+      subject.push(a);
+      clip.push(b);
+      a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
+      b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
+      a.o = b;
+      subject.push(a);
+      clip.push(b);
+    });
+    clip.sort(compare);
+    d3_geo_clipPolygonLinkCircular(subject);
+    d3_geo_clipPolygonLinkCircular(clip);
+    if (!subject.length) return;
+    for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
+      clip[i].e = entry = !entry;
+    }
+    var start = subject[0], points, point;
+    while (1) {
+      var current = start, isSubject = true;
+      while (current.v) if ((current = current.n) === start) return;
+      points = current.z;
+      listener.lineStart();
+      do {
+        current.v = current.o.v = true;
+        if (current.e) {
+          if (isSubject) {
+            for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
+          } else {
+            interpolate(current.x, current.n.x, 1, listener);
+          }
+          current = current.n;
+        } else {
+          if (isSubject) {
+            points = current.p.z;
+            for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
+          } else {
+            interpolate(current.x, current.p.x, -1, listener);
+          }
+          current = current.p;
+        }
+        current = current.o;
+        points = current.z;
+        isSubject = !isSubject;
+      } while (!current.v);
+      listener.lineEnd();
+    }
+  }
+  function d3_geo_clipPolygonLinkCircular(array) {
+    if (!(n = array.length)) return;
+    var n, i = 0, a = array[0], b;
+    while (++i < n) {
+      a.n = b = array[i];
+      b.p = a;
+      a = b;
+    }
+    a.n = b = array[0];
+    b.p = a;
+  }
+  function d3_geo_clipPolygonIntersection(point, points, other, entry) {
+    this.x = point;
+    this.z = points;
+    this.o = other;
+    this.e = entry;
+    this.v = false;
+    this.n = this.p = null;
+  }
+  function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
+    return function(rotate, listener) {
+      var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
+      var clip = {
+        point: point,
+        lineStart: lineStart,
+        lineEnd: lineEnd,
+        polygonStart: function() {
+          clip.point = pointRing;
+          clip.lineStart = ringStart;
+          clip.lineEnd = ringEnd;
+          segments = [];
+          polygon = [];
+        },
+        polygonEnd: function() {
+          clip.point = point;
+          clip.lineStart = lineStart;
+          clip.lineEnd = lineEnd;
+          segments = d3.merge(segments);
+          var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
+          if (segments.length) {
+            if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+            d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
+          } else if (clipStartInside) {
+            if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+            listener.lineStart();
+            interpolate(null, null, 1, listener);
+            listener.lineEnd();
+          }
+          if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
+          segments = polygon = null;
+        },
+        sphere: function() {
+          listener.polygonStart();
+          listener.lineStart();
+          interpolate(null, null, 1, listener);
+          listener.lineEnd();
+          listener.polygonEnd();
+        }
+      };
+      function point(λ, φ) {
+        var point = rotate(λ, φ);
+        if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
+      }
+      function pointLine(λ, φ) {
+        var point = rotate(λ, φ);
+        line.point(point[0], point[1]);
+      }
+      function lineStart() {
+        clip.point = pointLine;
+        line.lineStart();
+      }
+      function lineEnd() {
+        clip.point = point;
+        line.lineEnd();
+      }
+      var segments;
+      var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring;
+      function pointRing(λ, φ) {
+        ring.push([ λ, φ ]);
+        var point = rotate(λ, φ);
+        ringListener.point(point[0], point[1]);
+      }
+      function ringStart() {
+        ringListener.lineStart();
+        ring = [];
+      }
+      function ringEnd() {
+        pointRing(ring[0][0], ring[0][1]);
+        ringListener.lineEnd();
+        var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
+        ring.pop();
+        polygon.push(ring);
+        ring = null;
+        if (!n) return;
+        if (clean & 1) {
+          segment = ringSegments[0];
+          var n = segment.length - 1, i = -1, point;
+          if (n > 0) {
+            if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+            listener.lineStart();
+            while (++i < n) listener.point((point = segment[i])[0], point[1]);
+            listener.lineEnd();
+          }
+          return;
+        }
+        if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+        segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
+      }
+      return clip;
+    };
+  }
+  function d3_geo_clipSegmentLength1(segment) {
+    return segment.length > 1;
+  }
+  function d3_geo_clipBufferListener() {
+    var lines = [], line;
+    return {
+      lineStart: function() {
+        lines.push(line = []);
+      },
+      point: function(λ, φ) {
+        line.push([ λ, φ ]);
+      },
+      lineEnd: d3_noop,
+      buffer: function() {
+        var buffer = lines;
+        lines = [];
+        line = null;
+        return buffer;
+      },
+      rejoin: function() {
+        if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+      }
+    };
+  }
+  function d3_geo_clipSort(a, b) {
+    return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
+  }
+  var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]);
+  function d3_geo_clipAntimeridianLine(listener) {
+    var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean;
+    return {
+      lineStart: function() {
+        listener.lineStart();
+        clean = 1;
+      },
+      point: function(λ1, φ1) {
+        var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0);
+        if (abs(dλ - π) < ε) {
+          listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
+          listener.point(sλ0, φ0);
+          listener.lineEnd();
+          listener.lineStart();
+          listener.point(sλ1, φ0);
+          listener.point(λ1, φ0);
+          clean = 0;
+        } else if (sλ0 !== sλ1 && dλ >= π) {
+          if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
+          if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
+          φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
+          listener.point(sλ0, φ0);
+          listener.lineEnd();
+          listener.lineStart();
+          listener.point(sλ1, φ0);
+          clean = 0;
+        }
+        listener.point(λ0 = λ1, φ0 = φ1);
+        sλ0 = sλ1;
+      },
+      lineEnd: function() {
+        listener.lineEnd();
+        λ0 = φ0 = NaN;
+      },
+      clean: function() {
+        return 2 - clean;
+      }
+    };
+  }
+  function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
+    var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1);
+    return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2;
+  }
+  function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
+    var φ;
+    if (from == null) {
+      φ = direction * halfπ;
+      listener.point(-π, φ);
+      listener.point(0, φ);
+      listener.point(π, φ);
+      listener.point(π, 0);
+      listener.point(π, -φ);
+      listener.point(0, -φ);
+      listener.point(-π, -φ);
+      listener.point(-π, 0);
+      listener.point(-π, φ);
+    } else if (abs(from[0] - to[0]) > ε) {
+      var s = from[0] < to[0] ? π : -π;
+      φ = direction * s / 2;
+      listener.point(-s, φ);
+      listener.point(0, φ);
+      listener.point(s, φ);
+    } else {
+      listener.point(to[0], to[1]);
+    }
+  }
+  function d3_geo_pointInPolygon(point, polygon) {
+    var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0;
+    d3_geo_areaRingSum.reset();
+    for (var i = 0, n = polygon.length; i < n; ++i) {
+      var ring = polygon[i], m = ring.length;
+      if (!m) continue;
+      var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1;
+      while (true) {
+        if (j === m) j = 0;
+        point = ring[j];
+        var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ;
+        d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
+        polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
+        if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
+          var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
+          d3_geo_cartesianNormalize(arc);
+          var intersection = d3_geo_cartesianCross(meridianNormal, arc);
+          d3_geo_cartesianNormalize(intersection);
+          var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
+          if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
+            winding += antimeridian ^ dλ >= 0 ? 1 : -1;
+          }
+        }
+        if (!j++) break;
+        λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
+      }
+    }
+    return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < -ε) ^ winding & 1;
+  }
+  function d3_geo_clipCircle(radius) {
+    var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
+    return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]);
+    function visible(λ, φ) {
+      return Math.cos(λ) * Math.cos(φ) > cr;
+    }
+    function clipLine(listener) {
+      var point0, c0, v0, v00, clean;
+      return {
+        lineStart: function() {
+          v00 = v0 = false;
+          clean = 1;
+        },
+        point: function(λ, φ) {
+          var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
+          if (!point0 && (v00 = v0 = v)) listener.lineStart();
+          if (v !== v0) {
+            point2 = intersect(point0, point1);
+            if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
+              point1[0] += ε;
+              point1[1] += ε;
+              v = visible(point1[0], point1[1]);
+            }
+          }
+          if (v !== v0) {
+            clean = 0;
+            if (v) {
+              listener.lineStart();
+              point2 = intersect(point1, point0);
+              listener.point(point2[0], point2[1]);
+            } else {
+              point2 = intersect(point0, point1);
+              listener.point(point2[0], point2[1]);
+              listener.lineEnd();
+            }
+            point0 = point2;
+          } else if (notHemisphere && point0 && smallRadius ^ v) {
+            var t;
+            if (!(c & c0) && (t = intersect(point1, point0, true))) {
+              clean = 0;
+              if (smallRadius) {
+                listener.lineStart();
+                listener.point(t[0][0], t[0][1]);
+                listener.point(t[1][0], t[1][1]);
+                listener.lineEnd();
+              } else {
+                listener.point(t[1][0], t[1][1]);
+                listener.lineEnd();
+                listener.lineStart();
+                listener.point(t[0][0], t[0][1]);
+              }
+            }
+          }
+          if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
+            listener.point(point1[0], point1[1]);
+          }
+          point0 = point1, v0 = v, c0 = c;
+        },
+        lineEnd: function() {
+          if (v0) listener.lineEnd();
+          point0 = null;
+        },
+        clean: function() {
+          return clean | (v00 && v0) << 1;
+        }
+      };
+    }
+    function intersect(a, b, two) {
+      var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b);
+      var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
+      if (!determinant) return !two && a;
+      var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2);
+      d3_geo_cartesianAdd(A, B);
+      var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
+      if (t2 < 0) return;
+      var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu);
+      d3_geo_cartesianAdd(q, A);
+      q = d3_geo_spherical(q);
+      if (!two) return q;
+      var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z;
+      if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
+      var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε;
+      if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
+      if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
+        var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
+        d3_geo_cartesianAdd(q1, A);
+        return [ q, d3_geo_spherical(q1) ];
+      }
+    }
+    function code(λ, φ) {
+      var r = smallRadius ? radius : π - radius, code = 0;
+      if (λ < -r) code |= 1; else if (λ > r) code |= 2;
+      if (φ < -r) code |= 4; else if (φ > r) code |= 8;
+      return code;
+    }
+  }
+  function d3_geom_clipLine(x0, y0, x1, y1) {
+    return function(line) {
+      var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
+      r = x0 - ax;
+      if (!dx && r > 0) return;
+      r /= dx;
+      if (dx < 0) {
+        if (r < t0) return;
+        if (r < t1) t1 = r;
+      } else if (dx > 0) {
+        if (r > t1) return;
+        if (r > t0) t0 = r;
+      }
+      r = x1 - ax;
+      if (!dx && r < 0) return;
+      r /= dx;
+      if (dx < 0) {
+        if (r > t1) return;
+        if (r > t0) t0 = r;
+      } else if (dx > 0) {
+        if (r < t0) return;
+        if (r < t1) t1 = r;
+      }
+      r = y0 - ay;
+      if (!dy && r > 0) return;
+      r /= dy;
+      if (dy < 0) {
+        if (r < t0) return;
+        if (r < t1) t1 = r;
+      } else if (dy > 0) {
+        if (r > t1) return;
+        if (r > t0) t0 = r;
+      }
+      r = y1 - ay;
+      if (!dy && r < 0) return;
+      r /= dy;
+      if (dy < 0) {
+        if (r > t1) return;
+        if (r > t0) t0 = r;
+      } else if (dy > 0) {
+        if (r < t0) return;
+        if (r < t1) t1 = r;
+      }
+      if (t0 > 0) line.a = {
+        x: ax + t0 * dx,
+        y: ay + t0 * dy
+      };
+      if (t1 < 1) line.b = {
+        x: ax + t1 * dx,
+        y: ay + t1 * dy
+      };
+      return line;
+    };
+  }
+  var d3_geo_clipExtentMAX = 1e9;
+  d3.geo.clipExtent = function() {
+    var x0, y0, x1, y1, stream, clip, clipExtent = {
+      stream: function(output) {
+        if (stream) stream.valid = false;
+        stream = clip(output);
+        stream.valid = true;
+        return stream;
+      },
+      extent: function(_) {
+        if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+        clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
+        if (stream) stream.valid = false, stream = null;
+        return clipExtent;
+      }
+    };
+    return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]);
+  };
+  function d3_geo_clipExtent(x0, y0, x1, y1) {
+    return function(listener) {
+      var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring;
+      var clip = {
+        point: point,
+        lineStart: lineStart,
+        lineEnd: lineEnd,
+        polygonStart: function() {
+          listener = bufferListener;
+          segments = [];
+          polygon = [];
+          clean = true;
+        },
+        polygonEnd: function() {
+          listener = listener_;
+          segments = d3.merge(segments);
+          var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length;
+          if (inside || visible) {
+            listener.polygonStart();
+            if (inside) {
+              listener.lineStart();
+              interpolate(null, null, 1, listener);
+              listener.lineEnd();
+            }
+            if (visible) {
+              d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
+            }
+            listener.polygonEnd();
+          }
+          segments = polygon = ring = null;
+        }
+      };
+      function insidePolygon(p) {
+        var wn = 0, n = polygon.length, y = p[1];
+        for (var i = 0; i < n; ++i) {
+          for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
+            b = v[j];
+            if (a[1] <= y) {
+              if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn;
+            } else {
+              if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
+            }
+            a = b;
+          }
+        }
+        return wn !== 0;
+      }
+      function interpolate(from, to, direction, listener) {
+        var a = 0, a1 = 0;
+        if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) {
+          do {
+            listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
+          } while ((a = (a + direction + 4) % 4) !== a1);
+        } else {
+          listener.point(to[0], to[1]);
+        }
+      }
+      function pointVisible(x, y) {
+        return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+      }
+      function point(x, y) {
+        if (pointVisible(x, y)) listener.point(x, y);
+      }
+      var x__, y__, v__, x_, y_, v_, first, clean;
+      function lineStart() {
+        clip.point = linePoint;
+        if (polygon) polygon.push(ring = []);
+        first = true;
+        v_ = false;
+        x_ = y_ = NaN;
+      }
+      function lineEnd() {
+        if (segments) {
+          linePoint(x__, y__);
+          if (v__ && v_) bufferListener.rejoin();
+          segments.push(bufferListener.buffer());
+        }
+        clip.point = point;
+        if (v_) listener.lineEnd();
+      }
+      function linePoint(x, y) {
+        x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
+        y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
+        var v = pointVisible(x, y);
+        if (polygon) ring.push([ x, y ]);
+        if (first) {
+          x__ = x, y__ = y, v__ = v;
+          first = false;
+          if (v) {
+            listener.lineStart();
+            listener.point(x, y);
+          }
+        } else {
+          if (v && v_) listener.point(x, y); else {
+            var l = {
+              a: {
+                x: x_,
+                y: y_
+              },
+              b: {
+                x: x,
+                y: y
+              }
+            };
+            if (clipLine(l)) {
+              if (!v_) {
+                listener.lineStart();
+                listener.point(l.a.x, l.a.y);
+              }
+              listener.point(l.b.x, l.b.y);
+              if (!v) listener.lineEnd();
+              clean = false;
+            } else if (v) {
+              listener.lineStart();
+              listener.point(x, y);
+              clean = false;
+            }
+          }
+        }
+        x_ = x, y_ = y, v_ = v;
+      }
+      return clip;
+    };
+    function corner(p, direction) {
+      return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+    }
+    function compare(a, b) {
+      return comparePoints(a.x, b.x);
+    }
+    function comparePoints(a, b) {
+      var ca = corner(a, 1), cb = corner(b, 1);
+      return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
+    }
+  }
+  function d3_geo_conic(projectAt) {
+    var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1);
+    p.parallels = function(_) {
+      if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ];
+      return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+    };
+    return p;
+  }
+  function d3_geo_conicEqualArea(φ0, φ1) {
+    var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n;
+    function forward(λ, φ) {
+      var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
+      return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ];
+    }
+    forward.invert = function(x, y) {
+      var ρ0_y = ρ0 - y;
+      return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ];
+    };
+    return forward;
+  }
+  (d3.geo.conicEqualArea = function() {
+    return d3_geo_conic(d3_geo_conicEqualArea);
+  }).raw = d3_geo_conicEqualArea;
+  d3.geo.albers = function() {
+    return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070);
+  };
+  d3.geo.albersUsa = function() {
+    var lower48 = d3.geo.albers();
+    var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]);
+    var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]);
+    var point, pointStream = {
+      point: function(x, y) {
+        point = [ x, y ];
+      }
+    }, lower48Point, alaskaPoint, hawaiiPoint;
+    function albersUsa(coordinates) {
+      var x = coordinates[0], y = coordinates[1];
+      point = null;
+      (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y);
+      return point;
+    }
+    albersUsa.invert = function(coordinates) {
+      var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k;
+      return (y >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates);
+    };
+    albersUsa.stream = function(stream) {
+      var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
+      return {
+        point: function(x, y) {
+          lower48Stream.point(x, y);
+          alaskaStream.point(x, y);
+          hawaiiStream.point(x, y);
+        },
+        sphere: function() {
+          lower48Stream.sphere();
+          alaskaStream.sphere();
+          hawaiiStream.sphere();
+        },
+        lineStart: function() {
+          lower48Stream.lineStart();
+          alaskaStream.lineStart();
+          hawaiiStream.lineStart();
+        },
+        lineEnd: function() {
+          lower48Stream.lineEnd();
+          alaskaStream.lineEnd();
+          hawaiiStream.lineEnd();
+        },
+        polygonStart: function() {
+          lower48Stream.polygonStart();
+          alaskaStream.polygonStart();
+          hawaiiStream.polygonStart();
+        },
+        polygonEnd: function() {
+          lower48Stream.polygonEnd();
+          alaskaStream.polygonEnd();
+          hawaiiStream.polygonEnd();
+        }
+      };
+    };
+    albersUsa.precision = function(_) {
+      if (!arguments.length) return lower48.precision();
+      lower48.precision(_);
+      alaska.precision(_);
+      hawaii.precision(_);
+      return albersUsa;
+    };
+    albersUsa.scale = function(_) {
+      if (!arguments.length) return lower48.scale();
+      lower48.scale(_);
+      alaska.scale(_ * .35);
+      hawaii.scale(_);
+      return albersUsa.translate(lower48.translate());
+    };
+    albersUsa.translate = function(_) {
+      if (!arguments.length) return lower48.translate();
+      var k = lower48.scale(), x = +_[0], y = +_[1];
+      lower48Point = lower48.translate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
+      alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+      hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+      return albersUsa;
+    };
+    return albersUsa.scale(1070);
+  };
+  var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
+    point: d3_noop,
+    lineStart: d3_noop,
+    lineEnd: d3_noop,
+    polygonStart: function() {
+      d3_geo_pathAreaPolygon = 0;
+      d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
+    },
+    polygonEnd: function() {
+      d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
+      d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
+    }
+  };
+  function d3_geo_pathAreaRingStart() {
+    var x00, y00, x0, y0;
+    d3_geo_pathArea.point = function(x, y) {
+      d3_geo_pathArea.point = nextPoint;
+      x00 = x0 = x, y00 = y0 = y;
+    };
+    function nextPoint(x, y) {
+      d3_geo_pathAreaPolygon += y0 * x - x0 * y;
+      x0 = x, y0 = y;
+    }
+    d3_geo_pathArea.lineEnd = function() {
+      nextPoint(x00, y00);
+    };
+  }
+  var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
+  var d3_geo_pathBounds = {
+    point: d3_geo_pathBoundsPoint,
+    lineStart: d3_noop,
+    lineEnd: d3_noop,
+    polygonStart: d3_noop,
+    polygonEnd: d3_noop
+  };
+  function d3_geo_pathBoundsPoint(x, y) {
+    if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
+    if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
+    if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
+    if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
+  }
+  function d3_geo_pathBuffer() {
+    var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
+    var stream = {
+      point: point,
+      lineStart: function() {
+        stream.point = pointLineStart;
+      },
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        stream.lineEnd = lineEndPolygon;
+      },
+      polygonEnd: function() {
+        stream.lineEnd = lineEnd;
+        stream.point = point;
+      },
+      pointRadius: function(_) {
+        pointCircle = d3_geo_pathBufferCircle(_);
+        return stream;
+      },
+      result: function() {
+        if (buffer.length) {
+          var result = buffer.join("");
+          buffer = [];
+          return result;
+        }
+      }
+    };
+    function point(x, y) {
+      buffer.push("M", x, ",", y, pointCircle);
+    }
+    function pointLineStart(x, y) {
+      buffer.push("M", x, ",", y);
+      stream.point = pointLine;
+    }
+    function pointLine(x, y) {
+      buffer.push("L", x, ",", y);
+    }
+    function lineEnd() {
+      stream.point = point;
+    }
+    function lineEndPolygon() {
+      buffer.push("Z");
+    }
+    return stream;
+  }
+  function d3_geo_pathBufferCircle(radius) {
+    return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
+  }
+  var d3_geo_pathCentroid = {
+    point: d3_geo_pathCentroidPoint,
+    lineStart: d3_geo_pathCentroidLineStart,
+    lineEnd: d3_geo_pathCentroidLineEnd,
+    polygonStart: function() {
+      d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
+    },
+    polygonEnd: function() {
+      d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+      d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
+      d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
+    }
+  };
+  function d3_geo_pathCentroidPoint(x, y) {
+    d3_geo_centroidX0 += x;
+    d3_geo_centroidY0 += y;
+    ++d3_geo_centroidZ0;
+  }
+  function d3_geo_pathCentroidLineStart() {
+    var x0, y0;
+    d3_geo_pathCentroid.point = function(x, y) {
+      d3_geo_pathCentroid.point = nextPoint;
+      d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+    };
+    function nextPoint(x, y) {
+      var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+      d3_geo_centroidX1 += z * (x0 + x) / 2;
+      d3_geo_centroidY1 += z * (y0 + y) / 2;
+      d3_geo_centroidZ1 += z;
+      d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+    }
+  }
+  function d3_geo_pathCentroidLineEnd() {
+    d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+  }
+  function d3_geo_pathCentroidRingStart() {
+    var x00, y00, x0, y0;
+    d3_geo_pathCentroid.point = function(x, y) {
+      d3_geo_pathCentroid.point = nextPoint;
+      d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
+    };
+    function nextPoint(x, y) {
+      var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+      d3_geo_centroidX1 += z * (x0 + x) / 2;
+      d3_geo_centroidY1 += z * (y0 + y) / 2;
+      d3_geo_centroidZ1 += z;
+      z = y0 * x - x0 * y;
+      d3_geo_centroidX2 += z * (x0 + x);
+      d3_geo_centroidY2 += z * (y0 + y);
+      d3_geo_centroidZ2 += z * 3;
+      d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+    }
+    d3_geo_pathCentroid.lineEnd = function() {
+      nextPoint(x00, y00);
+    };
+  }
+  function d3_geo_pathContext(context) {
+    var pointRadius = 4.5;
+    var stream = {
+      point: point,
+      lineStart: function() {
+        stream.point = pointLineStart;
+      },
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        stream.lineEnd = lineEndPolygon;
+      },
+      polygonEnd: function() {
+        stream.lineEnd = lineEnd;
+        stream.point = point;
+      },
+      pointRadius: function(_) {
+        pointRadius = _;
+        return stream;
+      },
+      result: d3_noop
+    };
+    function point(x, y) {
+      context.moveTo(x + pointRadius, y);
+      context.arc(x, y, pointRadius, 0, τ);
+    }
+    function pointLineStart(x, y) {
+      context.moveTo(x, y);
+      stream.point = pointLine;
+    }
+    function pointLine(x, y) {
+      context.lineTo(x, y);
+    }
+    function lineEnd() {
+      stream.point = point;
+    }
+    function lineEndPolygon() {
+      context.closePath();
+    }
+    return stream;
+  }
+  function d3_geo_resample(project) {
+    var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16;
+    function resample(stream) {
+      return (maxDepth ? resampleRecursive : resampleNone)(stream);
+    }
+    function resampleNone(stream) {
+      return d3_geo_transformPoint(stream, function(x, y) {
+        x = project(x, y);
+        stream.point(x[0], x[1]);
+      });
+    }
+    function resampleRecursive(stream) {
+      var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0;
+      var resample = {
+        point: point,
+        lineStart: lineStart,
+        lineEnd: lineEnd,
+        polygonStart: function() {
+          stream.polygonStart();
+          resample.lineStart = ringStart;
+        },
+        polygonEnd: function() {
+          stream.polygonEnd();
+          resample.lineStart = lineStart;
+        }
+      };
+      function point(x, y) {
+        x = project(x, y);
+        stream.point(x[0], x[1]);
+      }
+      function lineStart() {
+        x0 = NaN;
+        resample.point = linePoint;
+        stream.lineStart();
+      }
+      function linePoint(λ, φ) {
+        var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ);
+        resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+        stream.point(x0, y0);
+      }
+      function lineEnd() {
+        resample.point = point;
+        stream.lineEnd();
+      }
+      function ringStart() {
+        lineStart();
+        resample.point = ringPoint;
+        resample.lineEnd = ringEnd;
+      }
+      function ringPoint(λ, φ) {
+        linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+        resample.point = linePoint;
+      }
+      function ringEnd() {
+        resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
+        resample.lineEnd = lineEnd;
+        lineEnd();
+      }
+      return resample;
+    }
+    function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
+      var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
+      if (d2 > 4 * δ2 && depth--) {
+        var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
+        if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+          resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
+          stream.point(x2, y2);
+          resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
+        }
+      }
+    }
+    resample.precision = function(_) {
+      if (!arguments.length) return Math.sqrt(δ2);
+      maxDepth = (δ2 = _ * _) > 0 && 16;
+      return resample;
+    };
+    return resample;
+  }
+  d3.geo.path = function() {
+    var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
+    function path(object) {
+      if (object) {
+        if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+        if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
+        d3.geo.stream(object, cacheStream);
+      }
+      return contextStream.result();
+    }
+    path.area = function(object) {
+      d3_geo_pathAreaSum = 0;
+      d3.geo.stream(object, projectStream(d3_geo_pathArea));
+      return d3_geo_pathAreaSum;
+    };
+    path.centroid = function(object) {
+      d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+      d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
+      return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ];
+    };
+    path.bounds = function(object) {
+      d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
+      d3.geo.stream(object, projectStream(d3_geo_pathBounds));
+      return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
+    };
+    path.projection = function(_) {
+      if (!arguments.length) return projection;
+      projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
+      return reset();
+    };
+    path.context = function(_) {
+      if (!arguments.length) return context;
+      contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
+      if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+      return reset();
+    };
+    path.pointRadius = function(_) {
+      if (!arguments.length) return pointRadius;
+      pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+      return path;
+    };
+    function reset() {
+      cacheStream = null;
+      return path;
+    }
+    return path.projection(d3.geo.albersUsa()).context(null);
+  };
+  function d3_geo_pathProjectStream(project) {
+    var resample = d3_geo_resample(function(x, y) {
+      return project([ x * d3_degrees, y * d3_degrees ]);
+    });
+    return function(stream) {
+      return d3_geo_projectionRadians(resample(stream));
+    };
+  }
+  d3.geo.transform = function(methods) {
+    return {
+      stream: function(stream) {
+        var transform = new d3_geo_transform(stream);
+        for (var k in methods) transform[k] = methods[k];
+        return transform;
+      }
+    };
+  };
+  function d3_geo_transform(stream) {
+    this.stream = stream;
+  }
+  d3_geo_transform.prototype = {
+    point: function(x, y) {
+      this.stream.point(x, y);
+    },
+    sphere: function() {
+      this.stream.sphere();
+    },
+    lineStart: function() {
+      this.stream.lineStart();
+    },
+    lineEnd: function() {
+      this.stream.lineEnd();
+    },
+    polygonStart: function() {
+      this.stream.polygonStart();
+    },
+    polygonEnd: function() {
+      this.stream.polygonEnd();
+    }
+  };
+  function d3_geo_transformPoint(stream, point) {
+    return {
+      point: point,
+      sphere: function() {
+        stream.sphere();
+      },
+      lineStart: function() {
+        stream.lineStart();
+      },
+      lineEnd: function() {
+        stream.lineEnd();
+      },
+      polygonStart: function() {
+        stream.polygonStart();
+      },
+      polygonEnd: function() {
+        stream.polygonEnd();
+      }
+    };
+  }
+  d3.geo.projection = d3_geo_projection;
+  d3.geo.projectionMutator = d3_geo_projectionMutator;
+  function d3_geo_projection(project) {
+    return d3_geo_projectionMutator(function() {
+      return project;
+    })();
+  }
+  function d3_geo_projectionMutator(projectAt) {
+    var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) {
+      x = project(x, y);
+      return [ x[0] * k + δx, δy - x[1] * k ];
+    }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream;
+    function projection(point) {
+      point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
+      return [ point[0] * k + δx, δy - point[1] * k ];
+    }
+    function invert(point) {
+      point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
+      return point && [ point[0] * d3_degrees, point[1] * d3_degrees ];
+    }
+    projection.stream = function(output) {
+      if (stream) stream.valid = false;
+      stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
+      stream.valid = true;
+      return stream;
+    };
+    projection.clipAngle = function(_) {
+      if (!arguments.length) return clipAngle;
+      preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
+      return invalidate();
+    };
+    projection.clipExtent = function(_) {
+      if (!arguments.length) return clipExtent;
+      clipExtent = _;
+      postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
+      return invalidate();
+    };
+    projection.scale = function(_) {
+      if (!arguments.length) return k;
+      k = +_;
+      return reset();
+    };
+    projection.translate = function(_) {
+      if (!arguments.length) return [ x, y ];
+      x = +_[0];
+      y = +_[1];
+      return reset();
+    };
+    projection.center = function(_) {
+      if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ];
+      λ = _[0] % 360 * d3_radians;
+      φ = _[1] % 360 * d3_radians;
+      return reset();
+    };
+    projection.rotate = function(_) {
+      if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ];
+      δλ = _[0] % 360 * d3_radians;
+      δφ = _[1] % 360 * d3_radians;
+      δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
+      return reset();
+    };
+    d3.rebind(projection, projectResample, "precision");
+    function reset() {
+      projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
+      var center = project(λ, φ);
+      δx = x - center[0] * k;
+      δy = y + center[1] * k;
+      return invalidate();
+    }
+    function invalidate() {
+      if (stream) stream.valid = false, stream = null;
+      return projection;
+    }
+    return function() {
+      project = projectAt.apply(this, arguments);
+      projection.invert = project.invert && invert;
+      return reset();
+    };
+  }
+  function d3_geo_projectionRadians(stream) {
+    return d3_geo_transformPoint(stream, function(x, y) {
+      stream.point(x * d3_radians, y * d3_radians);
+    });
+  }
+  function d3_geo_equirectangular(λ, φ) {
+    return [ λ, φ ];
+  }
+  (d3.geo.equirectangular = function() {
+    return d3_geo_projection(d3_geo_equirectangular);
+  }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
+  d3.geo.rotation = function(rotate) {
+    rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
+    function forward(coordinates) {
+      coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+      return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+    }
+    forward.invert = function(coordinates) {
+      coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+      return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+    };
+    return forward;
+  };
+  function d3_geo_identityRotation(λ, φ) {
+    return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+  }
+  d3_geo_identityRotation.invert = d3_geo_equirectangular;
+  function d3_geo_rotation(δλ, δφ, δγ) {
+    return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation;
+  }
+  function d3_geo_forwardRotationλ(δλ) {
+    return function(λ, φ) {
+      return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+    };
+  }
+  function d3_geo_rotationλ(δλ) {
+    var rotation = d3_geo_forwardRotationλ(δλ);
+    rotation.invert = d3_geo_forwardRotationλ(-δλ);
+    return rotation;
+  }
+  function d3_geo_rotationφγ(δφ, δγ) {
+    var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ);
+    function rotation(λ, φ) {
+      var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ;
+      return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ];
+    }
+    rotation.invert = function(λ, φ) {
+      var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ;
+      return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ];
+    };
+    return rotation;
+  }
+  d3.geo.circle = function() {
+    var origin = [ 0, 0 ], angle, precision = 6, interpolate;
+    function circle() {
+      var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = [];
+      interpolate(null, null, 1, {
+        point: function(x, y) {
+          ring.push(x = rotate(x, y));
+          x[0] *= d3_degrees, x[1] *= d3_degrees;
+        }
+      });
+      return {
+        type: "Polygon",
+        coordinates: [ ring ]
+      };
+    }
+    circle.origin = function(x) {
+      if (!arguments.length) return origin;
+      origin = x;
+      return circle;
+    };
+    circle.angle = function(x) {
+      if (!arguments.length) return angle;
+      interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
+      return circle;
+    };
+    circle.precision = function(_) {
+      if (!arguments.length) return precision;
+      interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
+      return circle;
+    };
+    return circle.angle(90);
+  };
+  function d3_geo_circleInterpolate(radius, precision) {
+    var cr = Math.cos(radius), sr = Math.sin(radius);
+    return function(from, to, direction, listener) {
+      var step = direction * precision;
+      if (from != null) {
+        from = d3_geo_circleAngle(cr, from);
+        to = d3_geo_circleAngle(cr, to);
+        if (direction > 0 ? from < to : from > to) from += direction * τ;
+      } else {
+        from = radius + direction * τ;
+        to = radius - .5 * step;
+      }
+      for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
+        listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]);
+      }
+    };
+  }
+  function d3_geo_circleAngle(cr, point) {
+    var a = d3_geo_cartesian(point);
+    a[0] -= cr;
+    d3_geo_cartesianNormalize(a);
+    var angle = d3_acos(-a[1]);
+    return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
+  }
+  d3.geo.distance = function(a, b) {
+    var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t;
+    return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
+  };
+  d3.geo.graticule = function() {
+    var x1, x0, X1, X0, y1, y0, Y1, Y0, dx = 10, dy = dx, DX = 90, DY = 360, x, y, X, Y, precision = 2.5;
+    function graticule() {
+      return {
+        type: "MultiLineString",
+        coordinates: lines()
+      };
+    }
+    function lines() {
+      return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) {
+        return abs(x % DX) > ε;
+      }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) {
+        return abs(y % DY) > ε;
+      }).map(y));
+    }
+    graticule.lines = function() {
+      return lines().map(function(coordinates) {
+        return {
+          type: "LineString",
+          coordinates: coordinates
+        };
+      });
+    };
+    graticule.outline = function() {
+      return {
+        type: "Polygon",
+        coordinates: [ X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1)) ]
+      };
+    };
+    graticule.extent = function(_) {
+      if (!arguments.length) return graticule.minorExtent();
+      return graticule.majorExtent(_).minorExtent(_);
+    };
+    graticule.majorExtent = function(_) {
+      if (!arguments.length) return [ [ X0, Y0 ], [ X1, Y1 ] ];
+      X0 = +_[0][0], X1 = +_[1][0];
+      Y0 = +_[0][1], Y1 = +_[1][1];
+      if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+      if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+      return graticule.precision(precision);
+    };
+    graticule.minorExtent = function(_) {
+      if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+      x0 = +_[0][0], x1 = +_[1][0];
+      y0 = +_[0][1], y1 = +_[1][1];
+      if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+      if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+      return graticule.precision(precision);
+    };
+    graticule.step = function(_) {
+      if (!arguments.length) return graticule.minorStep();
+      return graticule.majorStep(_).minorStep(_);
+    };
+    graticule.majorStep = function(_) {
+      if (!arguments.length) return [ DX, DY ];
+      DX = +_[0], DY = +_[1];
+      return graticule;
+    };
+    graticule.minorStep = function(_) {
+      if (!arguments.length) return [ dx, dy ];
+      dx = +_[0], dy = +_[1];
+      return graticule;
+    };
+    graticule.precision = function(_) {
+      if (!arguments.length) return precision;
+      precision = +_;
+      x = d3_geo_graticuleX(y0, y1, 90);
+      y = d3_geo_graticuleY(x0, x1, precision);
+      X = d3_geo_graticuleX(Y0, Y1, 90);
+      Y = d3_geo_graticuleY(X0, X1, precision);
+      return graticule;
+    };
+    return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]);
+  };
+  function d3_geo_graticuleX(y0, y1, dy) {
+    var y = d3.range(y0, y1 - ε, dy).concat(y1);
+    return function(x) {
+      return y.map(function(y) {
+        return [ x, y ];
+      });
+    };
+  }
+  function d3_geo_graticuleY(x0, x1, dx) {
+    var x = d3.range(x0, x1 - ε, dx).concat(x1);
+    return function(y) {
+      return x.map(function(x) {
+        return [ x, y ];
+      });
+    };
+  }
+  function d3_source(d) {
+    return d.source;
+  }
+  function d3_target(d) {
+    return d.target;
+  }
+  d3.geo.greatArc = function() {
+    var source = d3_source, source_, target = d3_target, target_;
+    function greatArc() {
+      return {
+        type: "LineString",
+        coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ]
+      };
+    }
+    greatArc.distance = function() {
+      return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments));
+    };
+    greatArc.source = function(_) {
+      if (!arguments.length) return source;
+      source = _, source_ = typeof _ === "function" ? null : _;
+      return greatArc;
+    };
+    greatArc.target = function(_) {
+      if (!arguments.length) return target;
+      target = _, target_ = typeof _ === "function" ? null : _;
+      return greatArc;
+    };
+    greatArc.precision = function() {
+      return arguments.length ? greatArc : 0;
+    };
+    return greatArc;
+  };
+  d3.geo.interpolate = function(source, target) {
+    return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians);
+  };
+  function d3_geo_interpolate(x0, y0, x1, y1) {
+    var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d);
+    var interpolate = d ? function(t) {
+      var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1;
+      return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ];
+    } : function() {
+      return [ x0 * d3_degrees, y0 * d3_degrees ];
+    };
+    interpolate.distance = d;
+    return interpolate;
+  }
+  d3.geo.length = function(object) {
+    d3_geo_lengthSum = 0;
+    d3.geo.stream(object, d3_geo_length);
+    return d3_geo_lengthSum;
+  };
+  var d3_geo_lengthSum;
+  var d3_geo_length = {
+    sphere: d3_noop,
+    point: d3_noop,
+    lineStart: d3_geo_lengthLineStart,
+    lineEnd: d3_noop,
+    polygonStart: d3_noop,
+    polygonEnd: d3_noop
+  };
+  function d3_geo_lengthLineStart() {
+    var λ0, sinφ0, cosφ0;
+    d3_geo_length.point = function(λ, φ) {
+      λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
+      d3_geo_length.point = nextPoint;
+    };
+    d3_geo_length.lineEnd = function() {
+      d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
+    };
+    function nextPoint(λ, φ) {
+      var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t);
+      d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
+      λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
+    }
+  }
+  function d3_geo_azimuthal(scale, angle) {
+    function azimuthal(λ, φ) {
+      var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ);
+      return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ];
+    }
+    azimuthal.invert = function(x, y) {
+      var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c);
+      return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ];
+    };
+    return azimuthal;
+  }
+  var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) {
+    return Math.sqrt(2 / (1 + cosλcosφ));
+  }, function(ρ) {
+    return 2 * Math.asin(ρ / 2);
+  });
+  (d3.geo.azimuthalEqualArea = function() {
+    return d3_geo_projection(d3_geo_azimuthalEqualArea);
+  }).raw = d3_geo_azimuthalEqualArea;
+  var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) {
+    var c = Math.acos(cosλcosφ);
+    return c && c / Math.sin(c);
+  }, d3_identity);
+  (d3.geo.azimuthalEquidistant = function() {
+    return d3_geo_projection(d3_geo_azimuthalEquidistant);
+  }).raw = d3_geo_azimuthalEquidistant;
+  function d3_geo_conicConformal(φ0, φ1) {
+    var cosφ0 = Math.cos(φ0), t = function(φ) {
+      return Math.tan(π / 4 + φ / 2);
+    }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n;
+    if (!n) return d3_geo_mercator;
+    function forward(λ, φ) {
+      if (F > 0) {
+        if (φ < -halfπ + ε) φ = -halfπ + ε;
+      } else {
+        if (φ > halfπ - ε) φ = halfπ - ε;
+      }
+      var ρ = F / Math.pow(t(φ), n);
+      return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ];
+    }
+    forward.invert = function(x, y) {
+      var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+      return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ];
+    };
+    return forward;
+  }
+  (d3.geo.conicConformal = function() {
+    return d3_geo_conic(d3_geo_conicConformal);
+  }).raw = d3_geo_conicConformal;
+  function d3_geo_conicEquidistant(φ0, φ1) {
+    var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0;
+    if (abs(n) < ε) return d3_geo_equirectangular;
+    function forward(λ, φ) {
+      var ρ = G - φ;
+      return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ];
+    }
+    forward.invert = function(x, y) {
+      var ρ0_y = G - y;
+      return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ];
+    };
+    return forward;
+  }
+  (d3.geo.conicEquidistant = function() {
+    return d3_geo_conic(d3_geo_conicEquidistant);
+  }).raw = d3_geo_conicEquidistant;
+  var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) {
+    return 1 / cosλcosφ;
+  }, Math.atan);
+  (d3.geo.gnomonic = function() {
+    return d3_geo_projection(d3_geo_gnomonic);
+  }).raw = d3_geo_gnomonic;
+  function d3_geo_mercator(λ, φ) {
+    return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ];
+  }
+  d3_geo_mercator.invert = function(x, y) {
+    return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ];
+  };
+  function d3_geo_mercatorProjection(project) {
+    var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto;
+    m.scale = function() {
+      var v = scale.apply(m, arguments);
+      return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+    };
+    m.translate = function() {
+      var v = translate.apply(m, arguments);
+      return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+    };
+    m.clipExtent = function(_) {
+      var v = clipExtent.apply(m, arguments);
+      if (v === m) {
+        if (clipAuto = _ == null) {
+          var k = π * scale(), t = translate();
+          clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]);
+        }
+      } else if (clipAuto) {
+        v = null;
+      }
+      return v;
+    };
+    return m.clipExtent(null);
+  }
+  (d3.geo.mercator = function() {
+    return d3_geo_mercatorProjection(d3_geo_mercator);
+  }).raw = d3_geo_mercator;
+  var d3_geo_orthographic = d3_geo_azimuthal(function() {
+    return 1;
+  }, Math.asin);
+  (d3.geo.orthographic = function() {
+    return d3_geo_projection(d3_geo_orthographic);
+  }).raw = d3_geo_orthographic;
+  var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) {
+    return 1 / (1 + cosλcosφ);
+  }, function(ρ) {
+    return 2 * Math.atan(ρ);
+  });
+  (d3.geo.stereographic = function() {
+    return d3_geo_projection(d3_geo_stereographic);
+  }).raw = d3_geo_stereographic;
+  function d3_geo_transverseMercator(λ, φ) {
+    return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ];
+  }
+  d3_geo_transverseMercator.invert = function(x, y) {
+    return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ];
+  };
+  (d3.geo.transverseMercator = function() {
+    var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate;
+    projection.center = function(_) {
+      return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ _[1], -_[0] ]);
+    };
+    projection.rotate = function(_) {
+      return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(), 
+      [ _[0], _[1], _[2] - 90 ]);
+    };
+    return rotate([ 0, 0, 90 ]);
+  }).raw = d3_geo_transverseMercator;
+  d3.geom = {};
+  function d3_geom_pointX(d) {
+    return d[0];
+  }
+  function d3_geom_pointY(d) {
+    return d[1];
+  }
+  d3.geom.hull = function(vertices) {
+    var x = d3_geom_pointX, y = d3_geom_pointY;
+    if (arguments.length) return hull(vertices);
+    function hull(data) {
+      if (data.length < 3) return [];
+      var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = [];
+      for (i = 0; i < n; i++) {
+        points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]);
+      }
+      points.sort(d3_geom_hullOrder);
+      for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]);
+      var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints);
+      var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = [];
+      for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
+      for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
+      return polygon;
+    }
+    hull.x = function(_) {
+      return arguments.length ? (x = _, hull) : x;
+    };
+    hull.y = function(_) {
+      return arguments.length ? (y = _, hull) : y;
+    };
+    return hull;
+  };
+  function d3_geom_hullUpper(points) {
+    var n = points.length, hull = [ 0, 1 ], hs = 2;
+    for (var i = 2; i < n; i++) {
+      while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs;
+      hull[hs++] = i;
+    }
+    return hull.slice(0, hs);
+  }
+  function d3_geom_hullOrder(a, b) {
+    return a[0] - b[0] || a[1] - b[1];
+  }
+  d3.geom.polygon = function(coordinates) {
+    d3_subclass(coordinates, d3_geom_polygonPrototype);
+    return coordinates;
+  };
+  var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
+  d3_geom_polygonPrototype.area = function() {
+    var i = -1, n = this.length, a, b = this[n - 1], area = 0;
+    while (++i < n) {
+      a = b;
+      b = this[i];
+      area += a[1] * b[0] - a[0] * b[1];
+    }
+    return area * .5;
+  };
+  d3_geom_polygonPrototype.centroid = function(k) {
+    var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c;
+    if (!arguments.length) k = -1 / (6 * this.area());
+    while (++i < n) {
+      a = b;
+      b = this[i];
+      c = a[0] * b[1] - b[0] * a[1];
+      x += (a[0] + b[0]) * c;
+      y += (a[1] + b[1]) * c;
+    }
+    return [ x * k, y * k ];
+  };
+  d3_geom_polygonPrototype.clip = function(subject) {
+    var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d;
+    while (++i < n) {
+      input = subject.slice();
+      subject.length = 0;
+      b = this[i];
+      c = input[(m = input.length - closed) - 1];
+      j = -1;
+      while (++j < m) {
+        d = input[j];
+        if (d3_geom_polygonInside(d, a, b)) {
+          if (!d3_geom_polygonInside(c, a, b)) {
+            subject.push(d3_geom_polygonIntersect(c, d, a, b));
+          }
+          subject.push(d);
+        } else if (d3_geom_polygonInside(c, a, b)) {
+          subject.push(d3_geom_polygonIntersect(c, d, a, b));
+        }
+        c = d;
+      }
+      if (closed) subject.push(subject[0]);
+      a = b;
+    }
+    return subject;
+  };
+  function d3_geom_polygonInside(p, a, b) {
+    return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
+  }
+  function d3_geom_polygonIntersect(c, d, a, b) {
+    var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
+    return [ x1 + ua * x21, y1 + ua * y21 ];
+  }
+  function d3_geom_polygonClosed(coordinates) {
+    var a = coordinates[0], b = coordinates[coordinates.length - 1];
+    return !(a[0] - b[0] || a[1] - b[1]);
+  }
+  var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = [];
+  function d3_geom_voronoiBeach() {
+    d3_geom_voronoiRedBlackNode(this);
+    this.edge = this.site = this.circle = null;
+  }
+  function d3_geom_voronoiCreateBeach(site) {
+    var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach();
+    beach.site = site;
+    return beach;
+  }
+  function d3_geom_voronoiDetachBeach(beach) {
+    d3_geom_voronoiDetachCircle(beach);
+    d3_geom_voronoiBeaches.remove(beach);
+    d3_geom_voronoiBeachPool.push(beach);
+    d3_geom_voronoiRedBlackNode(beach);
+  }
+  function d3_geom_voronoiRemoveBeach(beach) {
+    var circle = beach.circle, x = circle.x, y = circle.cy, vertex = {
+      x: x,
+      y: y
+    }, previous = beach.P, next = beach.N, disappearing = [ beach ];
+    d3_geom_voronoiDetachBeach(beach);
+    var lArc = previous;
+    while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) {
+      previous = lArc.P;
+      disappearing.unshift(lArc);
+      d3_geom_voronoiDetachBeach(lArc);
+      lArc = previous;
+    }
+    disappearing.unshift(lArc);
+    d3_geom_voronoiDetachCircle(lArc);
+    var rArc = next;
+    while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) {
+      next = rArc.N;
+      disappearing.push(rArc);
+      d3_geom_voronoiDetachBeach(rArc);
+      rArc = next;
+    }
+    disappearing.push(rArc);
+    d3_geom_voronoiDetachCircle(rArc);
+    var nArcs = disappearing.length, iArc;
+    for (iArc = 1; iArc < nArcs; ++iArc) {
+      rArc = disappearing[iArc];
+      lArc = disappearing[iArc - 1];
+      d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);
+    }
+    lArc = disappearing[0];
+    rArc = disappearing[nArcs - 1];
+    rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex);
+    d3_geom_voronoiAttachCircle(lArc);
+    d3_geom_voronoiAttachCircle(rArc);
+  }
+  function d3_geom_voronoiAddBeach(site) {
+    var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._;
+    while (node) {
+      dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x;
+      if (dxl > ε) node = node.L; else {
+        dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix);
+        if (dxr > ε) {
+          if (!node.R) {
+            lArc = node;
+            break;
+          }
+          node = node.R;
+        } else {
+          if (dxl > -ε) {
+            lArc = node.P;
+            rArc = node;
+          } else if (dxr > -ε) {
+            lArc = node;
+            rArc = node.N;
+          } else {
+            lArc = rArc = node;
+          }
+          break;
+        }
+      }
+    }
+    var newArc = d3_geom_voronoiCreateBeach(site);
+    d3_geom_voronoiBeaches.insert(lArc, newArc);
+    if (!lArc && !rArc) return;
+    if (lArc === rArc) {
+      d3_geom_voronoiDetachCircle(lArc);
+      rArc = d3_geom_voronoiCreateBeach(lArc.site);
+      d3_geom_voronoiBeaches.insert(newArc, rArc);
+      newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+      d3_geom_voronoiAttachCircle(lArc);
+      d3_geom_voronoiAttachCircle(rArc);
+      return;
+    }
+    if (!rArc) {
+      newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+      return;
+    }
+    d3_geom_voronoiDetachCircle(lArc);
+    d3_geom_voronoiDetachCircle(rArc);
+    var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = {
+      x: (cy * hb - by * hc) / d + ax,
+      y: (bx * hc - cx * hb) / d + ay
+    };
+    d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex);
+    newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex);
+    rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex);
+    d3_geom_voronoiAttachCircle(lArc);
+    d3_geom_voronoiAttachCircle(rArc);
+  }
+  function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
+    var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix;
+    if (!pby2) return rfocx;
+    var lArc = arc.P;
+    if (!lArc) return -Infinity;
+    site = lArc.site;
+    var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix;
+    if (!plby2) return lfocx;
+    var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2;
+    if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
+    return (rfocx + lfocx) / 2;
+  }
+  function d3_geom_voronoiRightBreakPoint(arc, directrix) {
+    var rArc = arc.N;
+    if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
+    var site = arc.site;
+    return site.y === directrix ? site.x : Infinity;
+  }
+  function d3_geom_voronoiCell(site) {
+    this.site = site;
+    this.edges = [];
+  }
+  d3_geom_voronoiCell.prototype.prepare = function() {
+    var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge;
+    while (iHalfEdge--) {
+      edge = halfEdges[iHalfEdge].edge;
+      if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
+    }
+    halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
+    return halfEdges.length;
+  };
+  function d3_geom_voronoiCloseCells(extent) {
+    var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end;
+    while (iCell--) {
+      cell = cells[iCell];
+      if (!cell || !cell.prepare()) continue;
+      halfEdges = cell.edges;
+      nHalfEdges = halfEdges.length;
+      iHalfEdge = 0;
+      while (iHalfEdge < nHalfEdges) {
+        end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
+        start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
+        if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
+          halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? {
+            x: x0,
+            y: abs(x2 - x0) < ε ? y2 : y1
+          } : abs(y3 - y1) < ε && x1 - x3 > ε ? {
+            x: abs(y2 - y1) < ε ? x2 : x1,
+            y: y1
+          } : abs(x3 - x1) < ε && y3 - y0 > ε ? {
+            x: x1,
+            y: abs(x2 - x1) < ε ? y2 : y0
+          } : abs(y3 - y0) < ε && x3 - x0 > ε ? {
+            x: abs(y2 - y0) < ε ? x2 : x0,
+            y: y0
+          } : null), cell.site, null));
+          ++nHalfEdges;
+        }
+      }
+    }
+  }
+  function d3_geom_voronoiHalfEdgeOrder(a, b) {
+    return b.angle - a.angle;
+  }
+  function d3_geom_voronoiCircle() {
+    d3_geom_voronoiRedBlackNode(this);
+    this.x = this.y = this.arc = this.site = this.cy = null;
+  }
+  function d3_geom_voronoiAttachCircle(arc) {
+    var lArc = arc.P, rArc = arc.N;
+    if (!lArc || !rArc) return;
+    var lSite = lArc.site, cSite = arc.site, rSite = rArc.site;
+    if (lSite === rSite) return;
+    var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by;
+    var d = 2 * (ax * cy - ay * cx);
+    if (d >= -ε2) return;
+    var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by;
+    var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle();
+    circle.arc = arc;
+    circle.site = cSite;
+    circle.x = x + bx;
+    circle.y = cy + Math.sqrt(x * x + y * y);
+    circle.cy = cy;
+    arc.circle = circle;
+    var before = null, node = d3_geom_voronoiCircles._;
+    while (node) {
+      if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) {
+        if (node.L) node = node.L; else {
+          before = node.P;
+          break;
+        }
+      } else {
+        if (node.R) node = node.R; else {
+          before = node;
+          break;
+        }
+      }
+    }
+    d3_geom_voronoiCircles.insert(before, circle);
+    if (!before) d3_geom_voronoiFirstCircle = circle;
+  }
+  function d3_geom_voronoiDetachCircle(arc) {
+    var circle = arc.circle;
+    if (circle) {
+      if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
+      d3_geom_voronoiCircles.remove(circle);
+      d3_geom_voronoiCirclePool.push(circle);
+      d3_geom_voronoiRedBlackNode(circle);
+      arc.circle = null;
+    }
+  }
+  function d3_geom_voronoiClipEdges(extent) {
+    var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e;
+    while (i--) {
+      e = edges[i];
+      if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) {
+        e.a = e.b = null;
+        edges.splice(i, 1);
+      }
+    }
+  }
+  function d3_geom_voronoiConnectEdge(edge, extent) {
+    var vb = edge.b;
+    if (vb) return true;
+    var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb;
+    if (ry === ly) {
+      if (fx < x0 || fx >= x1) return;
+      if (lx > rx) {
+        if (!va) va = {
+          x: fx,
+          y: y0
+        }; else if (va.y >= y1) return;
+        vb = {
+          x: fx,
+          y: y1
+        };
+      } else {
+        if (!va) va = {
+          x: fx,
+          y: y1
+        }; else if (va.y < y0) return;
+        vb = {
+          x: fx,
+          y: y0
+        };
+      }
+    } else {
+      fm = (lx - rx) / (ry - ly);
+      fb = fy - fm * fx;
+      if (fm < -1 || fm > 1) {
+        if (lx > rx) {
+          if (!va) va = {
+            x: (y0 - fb) / fm,
+            y: y0
+          }; else if (va.y >= y1) return;
+          vb = {
+            x: (y1 - fb) / fm,
+            y: y1
+          };
+        } else {
+          if (!va) va = {
+            x: (y1 - fb) / fm,
+            y: y1
+          }; else if (va.y < y0) return;
+          vb = {
+            x: (y0 - fb) / fm,
+            y: y0
+          };
+        }
+      } else {
+        if (ly < ry) {
+          if (!va) va = {
+            x: x0,
+            y: fm * x0 + fb
+          }; else if (va.x >= x1) return;
+          vb = {
+            x: x1,
+            y: fm * x1 + fb
+          };
+        } else {
+          if (!va) va = {
+            x: x1,
+            y: fm * x1 + fb
+          }; else if (va.x < x0) return;
+          vb = {
+            x: x0,
+            y: fm * x0 + fb
+          };
+        }
+      }
+    }
+    edge.a = va;
+    edge.b = vb;
+    return true;
+  }
+  function d3_geom_voronoiEdge(lSite, rSite) {
+    this.l = lSite;
+    this.r = rSite;
+    this.a = this.b = null;
+  }
+  function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
+    var edge = new d3_geom_voronoiEdge(lSite, rSite);
+    d3_geom_voronoiEdges.push(edge);
+    if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va);
+    if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb);
+    d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
+    d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
+    return edge;
+  }
+  function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
+    var edge = new d3_geom_voronoiEdge(lSite, null);
+    edge.a = va;
+    edge.b = vb;
+    d3_geom_voronoiEdges.push(edge);
+    return edge;
+  }
+  function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
+    if (!edge.a && !edge.b) {
+      edge.a = vertex;
+      edge.l = lSite;
+      edge.r = rSite;
+    } else if (edge.l === rSite) {
+      edge.b = vertex;
+    } else {
+      edge.a = vertex;
+    }
+  }
+  function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
+    var va = edge.a, vb = edge.b;
+    this.edge = edge;
+    this.site = lSite;
+    this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y);
+  }
+  d3_geom_voronoiHalfEdge.prototype = {
+    start: function() {
+      return this.edge.l === this.site ? this.edge.a : this.edge.b;
+    },
+    end: function() {
+      return this.edge.l === this.site ? this.edge.b : this.edge.a;
+    }
+  };
+  function d3_geom_voronoiRedBlackTree() {
+    this._ = null;
+  }
+  function d3_geom_voronoiRedBlackNode(node) {
+    node.U = node.C = node.L = node.R = node.P = node.N = null;
+  }
+  d3_geom_voronoiRedBlackTree.prototype = {
+    insert: function(after, node) {
+      var parent, grandpa, uncle;
+      if (after) {
+        node.P = after;
+        node.N = after.N;
+        if (after.N) after.N.P = node;
+        after.N = node;
+        if (after.R) {
+          after = after.R;
+          while (after.L) after = after.L;
+          after.L = node;
+        } else {
+          after.R = node;
+        }
+        parent = after;
+      } else if (this._) {
+        after = d3_geom_voronoiRedBlackFirst(this._);
+        node.P = null;
+        node.N = after;
+        after.P = after.L = node;
+        parent = after;
+      } else {
+        node.P = node.N = null;
+        this._ = node;
+        parent = null;
+      }
+      node.L = node.R = null;
+      node.U = parent;
+      node.C = true;
+      after = node;
+      while (parent && parent.C) {
+        grandpa = parent.U;
+        if (parent === grandpa.L) {
+          uncle = grandpa.R;
+          if (uncle && uncle.C) {
+            parent.C = uncle.C = false;
+            grandpa.C = true;
+            after = grandpa;
+          } else {
+            if (after === parent.R) {
+              d3_geom_voronoiRedBlackRotateLeft(this, parent);
+              after = parent;
+              parent = after.U;
+            }
+            parent.C = false;
+            grandpa.C = true;
+            d3_geom_voronoiRedBlackRotateRight(this, grandpa);
+          }
+        } else {
+          uncle = grandpa.L;
+          if (uncle && uncle.C) {
+            parent.C = uncle.C = false;
+            grandpa.C = true;
+            after = grandpa;
+          } else {
+            if (after === parent.L) {
+              d3_geom_voronoiRedBlackRotateRight(this, parent);
+              after = parent;
+              parent = after.U;
+            }
+            parent.C = false;
+            grandpa.C = true;
+            d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
+          }
+        }
+        parent = after.U;
+      }
+      this._.C = false;
+    },
+    remove: function(node) {
+      if (node.N) node.N.P = node.P;
+      if (node.P) node.P.N = node.N;
+      node.N = node.P = null;
+      var parent = node.U, sibling, left = node.L, right = node.R, next, red;
+      if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right);
+      if (parent) {
+        if (parent.L === node) parent.L = next; else parent.R = next;
+      } else {
+        this._ = next;
+      }
+      if (left && right) {
+        red = next.C;
+        next.C = node.C;
+        next.L = left;
+        left.U = next;
+        if (next !== right) {
+          parent = next.U;
+          next.U = node.U;
+          node = next.R;
+          parent.L = node;
+          next.R = right;
+          right.U = next;
+        } else {
+          next.U = parent;
+          parent = next;
+          node = next.R;
+        }
+      } else {
+        red = node.C;
+        node = next;
+      }
+      if (node) node.U = parent;
+      if (red) return;
+      if (node && node.C) {
+        node.C = false;
+        return;
+      }
+      do {
+        if (node === this._) break;
+        if (node === parent.L) {
+          sibling = parent.R;
+          if (sibling.C) {
+            sibling.C = false;
+            parent.C = true;
+            d3_geom_voronoiRedBlackRotateLeft(this, parent);
+            sibling = parent.R;
+          }
+          if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+            if (!sibling.R || !sibling.R.C) {
+              sibling.L.C = false;
+              sibling.C = true;
+              d3_geom_voronoiRedBlackRotateRight(this, sibling);
+              sibling = parent.R;
+            }
+            sibling.C = parent.C;
+            parent.C = sibling.R.C = false;
+            d3_geom_voronoiRedBlackRotateLeft(this, parent);
+            node = this._;
+            break;
+          }
+        } else {
+          sibling = parent.L;
+          if (sibling.C) {
+            sibling.C = false;
+            parent.C = true;
+            d3_geom_voronoiRedBlackRotateRight(this, parent);
+            sibling = parent.L;
+          }
+          if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+            if (!sibling.L || !sibling.L.C) {
+              sibling.R.C = false;
+              sibling.C = true;
+              d3_geom_voronoiRedBlackRotateLeft(this, sibling);
+              sibling = parent.L;
+            }
+            sibling.C = parent.C;
+            parent.C = sibling.L.C = false;
+            d3_geom_voronoiRedBlackRotateRight(this, parent);
+            node = this._;
+            break;
+          }
+        }
+        sibling.C = true;
+        node = parent;
+        parent = parent.U;
+      } while (!node.C);
+      if (node) node.C = false;
+    }
+  };
+  function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
+    var p = node, q = node.R, parent = p.U;
+    if (parent) {
+      if (parent.L === p) parent.L = q; else parent.R = q;
+    } else {
+      tree._ = q;
+    }
+    q.U = parent;
+    p.U = q;
+    p.R = q.L;
+    if (p.R) p.R.U = p;
+    q.L = p;
+  }
+  function d3_geom_voronoiRedBlackRotateRight(tree, node) {
+    var p = node, q = node.L, parent = p.U;
+    if (parent) {
+      if (parent.L === p) parent.L = q; else parent.R = q;
+    } else {
+      tree._ = q;
+    }
+    q.U = parent;
+    p.U = q;
+    p.L = q.R;
+    if (p.L) p.L.U = p;
+    q.R = p;
+  }
+  function d3_geom_voronoiRedBlackFirst(node) {
+    while (node.L) node = node.L;
+    return node;
+  }
+  function d3_geom_voronoi(sites, bbox) {
+    var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle;
+    d3_geom_voronoiEdges = [];
+    d3_geom_voronoiCells = new Array(sites.length);
+    d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree();
+    d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree();
+    while (true) {
+      circle = d3_geom_voronoiFirstCircle;
+      if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) {
+        if (site.x !== x0 || site.y !== y0) {
+          d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
+          d3_geom_voronoiAddBeach(site);
+          x0 = site.x, y0 = site.y;
+        }
+        site = sites.pop();
+      } else if (circle) {
+        d3_geom_voronoiRemoveBeach(circle.arc);
+      } else {
+        break;
+      }
+    }
+    if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
+    var diagram = {
+      cells: d3_geom_voronoiCells,
+      edges: d3_geom_voronoiEdges
+    };
+    d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null;
+    return diagram;
+  }
+  function d3_geom_voronoiVertexOrder(a, b) {
+    return b.y - a.y || b.x - a.x;
+  }
+  d3.geom.voronoi = function(points) {
+    var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent;
+    if (points) return voronoi(points);
+    function voronoi(data) {
+      var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1];
+      d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) {
+        var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) {
+          var s = e.start();
+          return [ s.x, s.y ];
+        }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : [];
+        polygon.point = data[i];
+      });
+      return polygons;
+    }
+    function sites(data) {
+      return data.map(function(d, i) {
+        return {
+          x: Math.round(fx(d, i) / ε) * ε,
+          y: Math.round(fy(d, i) / ε) * ε,
+          i: i
+        };
+      });
+    }
+    voronoi.links = function(data) {
+      return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
+        return edge.l && edge.r;
+      }).map(function(edge) {
+        return {
+          source: data[edge.l.i],
+          target: data[edge.r.i]
+        };
+      });
+    };
+    voronoi.triangles = function(data) {
+      var triangles = [];
+      d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) {
+        var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l;
+        while (++j < m) {
+          e0 = e1;
+          s0 = s1;
+          e1 = edges[j].edge;
+          s1 = e1.l === site ? e1.r : e1.l;
+          if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
+            triangles.push([ data[i], data[s0.i], data[s1.i] ]);
+          }
+        }
+      });
+      return triangles;
+    };
+    voronoi.x = function(_) {
+      return arguments.length ? (fx = d3_functor(x = _), voronoi) : x;
+    };
+    voronoi.y = function(_) {
+      return arguments.length ? (fy = d3_functor(y = _), voronoi) : y;
+    };
+    voronoi.clipExtent = function(_) {
+      if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
+      clipExtent = _ == null ? d3_geom_voronoiClipExtent : _;
+      return voronoi;
+    };
+    voronoi.size = function(_) {
+      if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
+      return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]);
+    };
+    return voronoi;
+  };
+  var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ];
+  function d3_geom_voronoiTriangleArea(a, b, c) {
+    return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y);
+  }
+  d3.geom.delaunay = function(vertices) {
+    return d3.geom.voronoi().triangles(vertices);
+  };
+  d3.geom.quadtree = function(points, x1, y1, x2, y2) {
+    var x = d3_geom_pointX, y = d3_geom_pointY, compat;
+    if (compat = arguments.length) {
+      x = d3_geom_quadtreeCompatX;
+      y = d3_geom_quadtreeCompatY;
+      if (compat === 3) {
+        y2 = y1;
+        x2 = x1;
+        y1 = x1 = 0;
+      }
+      return quadtree(points);
+    }
+    function quadtree(data) {
+      var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_;
+      if (x1 != null) {
+        x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
+      } else {
+        x2_ = y2_ = -(x1_ = y1_ = Infinity);
+        xs = [], ys = [];
+        n = data.length;
+        if (compat) for (i = 0; i < n; ++i) {
+          d = data[i];
+          if (d.x < x1_) x1_ = d.x;
+          if (d.y < y1_) y1_ = d.y;
+          if (d.x > x2_) x2_ = d.x;
+          if (d.y > y2_) y2_ = d.y;
+          xs.push(d.x);
+          ys.push(d.y);
+        } else for (i = 0; i < n; ++i) {
+          var x_ = +fx(d = data[i], i), y_ = +fy(d, i);
+          if (x_ < x1_) x1_ = x_;
+          if (y_ < y1_) y1_ = y_;
+          if (x_ > x2_) x2_ = x_;
+          if (y_ > y2_) y2_ = y_;
+          xs.push(x_);
+          ys.push(y_);
+        }
+      }
+      var dx = x2_ - x1_, dy = y2_ - y1_;
+      if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy;
+      function insert(n, d, x, y, x1, y1, x2, y2) {
+        if (isNaN(x) || isNaN(y)) return;
+        if (n.leaf) {
+          var nx = n.x, ny = n.y;
+          if (nx != null) {
+            if (abs(nx - x) + abs(ny - y) < .01) {
+              insertChild(n, d, x, y, x1, y1, x2, y2);
+            } else {
+              var nPoint = n.point;
+              n.x = n.y = n.point = null;
+              insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
+              insertChild(n, d, x, y, x1, y1, x2, y2);
+            }
+          } else {
+            n.x = x, n.y = y, n.point = d;
+          }
+        } else {
+          insertChild(n, d, x, y, x1, y1, x2, y2);
+        }
+      }
+      function insertChild(n, d, x, y, x1, y1, x2, y2) {
+        var xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym, i = below << 1 | right;
+        n.leaf = false;
+        n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());
+        if (right) x1 = xm; else x2 = xm;
+        if (below) y1 = ym; else y2 = ym;
+        insert(n, d, x, y, x1, y1, x2, y2);
+      }
+      var root = d3_geom_quadtreeNode();
+      root.add = function(d) {
+        insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
+      };
+      root.visit = function(f) {
+        d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
+      };
+      root.find = function(point) {
+        return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
+      };
+      i = -1;
+      if (x1 == null) {
+        while (++i < n) {
+          insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
+        }
+        --i;
+      } else data.forEach(root.add);
+      xs = ys = data = d = null;
+      return root;
+    }
+    quadtree.x = function(_) {
+      return arguments.length ? (x = _, quadtree) : x;
+    };
+    quadtree.y = function(_) {
+      return arguments.length ? (y = _, quadtree) : y;
+    };
+    quadtree.extent = function(_) {
+      if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ];
+      if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], 
+      y2 = +_[1][1];
+      return quadtree;
+    };
+    quadtree.size = function(_) {
+      if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ];
+      if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
+      return quadtree;
+    };
+    return quadtree;
+  };
+  function d3_geom_quadtreeCompatX(d) {
+    return d.x;
+  }
+  function d3_geom_quadtreeCompatY(d) {
+    return d.y;
+  }
+  function d3_geom_quadtreeNode() {
+    return {
+      leaf: true,
+      nodes: [],
+      point: null,
+      x: null,
+      y: null
+    };
+  }
+  function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
+    if (!f(node, x1, y1, x2, y2)) {
+      var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes;
+      if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
+      if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
+      if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
+      if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
+    }
+  }
+  function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
+    var minDistance2 = Infinity, closestPoint;
+    (function find(node, x1, y1, x2, y2) {
+      if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return;
+      if (point = node.point) {
+        var point, dx = x - node.x, dy = y - node.y, distance2 = dx * dx + dy * dy;
+        if (distance2 < minDistance2) {
+          var distance = Math.sqrt(minDistance2 = distance2);
+          x0 = x - distance, y0 = y - distance;
+          x3 = x + distance, y3 = y + distance;
+          closestPoint = point;
+        }
+      }
+      var children = node.nodes, xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym;
+      for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
+        if (node = children[i & 3]) switch (i & 3) {
+         case 0:
+          find(node, x1, y1, xm, ym);
+          break;
+
+         case 1:
+          find(node, xm, y1, x2, ym);
+          break;
+
+         case 2:
+          find(node, x1, ym, xm, y2);
+          break;
+
+         case 3:
+          find(node, xm, ym, x2, y2);
+          break;
+        }
+      }
+    })(root, x0, y0, x3, y3);
+    return closestPoint;
+  }
+  d3.interpolateRgb = d3_interpolateRgb;
+  function d3_interpolateRgb(a, b) {
+    a = d3.rgb(a);
+    b = d3.rgb(b);
+    var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;
+    return function(t) {
+      return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t));
+    };
+  }
+  d3.interpolateObject = d3_interpolateObject;
+  function d3_interpolateObject(a, b) {
+    var i = {}, c = {}, k;
+    for (k in a) {
+      if (k in b) {
+        i[k] = d3_interpolate(a[k], b[k]);
+      } else {
+        c[k] = a[k];
+      }
+    }
+    for (k in b) {
+      if (!(k in a)) {
+        c[k] = b[k];
+      }
+    }
+    return function(t) {
+      for (k in i) c[k] = i[k](t);
+      return c;
+    };
+  }
+  d3.interpolateNumber = d3_interpolateNumber;
+  function d3_interpolateNumber(a, b) {
+    a = +a, b = +b;
+    return function(t) {
+      return a * (1 - t) + b * t;
+    };
+  }
+  d3.interpolateString = d3_interpolateString;
+  function d3_interpolateString(a, b) {
+    var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+    a = a + "", b = b + "";
+    while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) {
+      if ((bs = bm.index) > bi) {
+        bs = b.slice(bi, bs);
+        if (s[i]) s[i] += bs; else s[++i] = bs;
+      }
+      if ((am = am[0]) === (bm = bm[0])) {
+        if (s[i]) s[i] += bm; else s[++i] = bm;
+      } else {
+        s[++i] = null;
+        q.push({
+          i: i,
+          x: d3_interpolateNumber(am, bm)
+        });
+      }
+      bi = d3_interpolate_numberB.lastIndex;
+    }
+    if (bi < b.length) {
+      bs = b.slice(bi);
+      if (s[i]) s[i] += bs; else s[++i] = bs;
+    }
+    return s.length < 2 ? q[0] ? (b = q[0].x, function(t) {
+      return b(t) + "";
+    }) : function() {
+      return b;
+    } : (b = q.length, function(t) {
+      for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
+      return s.join("");
+    });
+  }
+  var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");
+  d3.interpolate = d3_interpolate;
+  function d3_interpolate(a, b) {
+    var i = d3.interpolators.length, f;
+    while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ;
+    return f;
+  }
+  d3.interpolators = [ function(a, b) {
+    var t = typeof b;
+    return (t === "string" ? d3_rgb_names.has(b.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);
+  } ];
+  d3.interpolateArray = d3_interpolateArray;
+  function d3_interpolateArray(a, b) {
+    var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i;
+    for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i]));
+    for (;i < na; ++i) c[i] = a[i];
+    for (;i < nb; ++i) c[i] = b[i];
+    return function(t) {
+      for (i = 0; i < n0; ++i) c[i] = x[i](t);
+      return c;
+    };
+  }
+  var d3_ease_default = function() {
+    return d3_identity;
+  };
+  var d3_ease = d3.map({
+    linear: d3_ease_default,
+    poly: d3_ease_poly,
+    quad: function() {
+      return d3_ease_quad;
+    },
+    cubic: function() {
+      return d3_ease_cubic;
+    },
+    sin: function() {
+      return d3_ease_sin;
+    },
+    exp: function() {
+      return d3_ease_exp;
+    },
+    circle: function() {
+      return d3_ease_circle;
+    },
+    elastic: d3_ease_elastic,
+    back: d3_ease_back,
+    bounce: function() {
+      return d3_ease_bounce;
+    }
+  });
+  var d3_ease_mode = d3.map({
+    "in": d3_identity,
+    out: d3_ease_reverse,
+    "in-out": d3_ease_reflect,
+    "out-in": function(f) {
+      return d3_ease_reflect(d3_ease_reverse(f));
+    }
+  });
+  d3.ease = function(name) {
+    var i = name.indexOf("-"), t = i >= 0 ? name.slice(0, i) : name, m = i >= 0 ? name.slice(i + 1) : "in";
+    t = d3_ease.get(t) || d3_ease_default;
+    m = d3_ease_mode.get(m) || d3_identity;
+    return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));
+  };
+  function d3_ease_clamp(f) {
+    return function(t) {
+      return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
+    };
+  }
+  function d3_ease_reverse(f) {
+    return function(t) {
+      return 1 - f(1 - t);
+    };
+  }
+  function d3_ease_reflect(f) {
+    return function(t) {
+      return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t));
+    };
+  }
+  function d3_ease_quad(t) {
+    return t * t;
+  }
+  function d3_ease_cubic(t) {
+    return t * t * t;
+  }
+  function d3_ease_cubicInOut(t) {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    var t2 = t * t, t3 = t2 * t;
+    return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
+  }
+  function d3_ease_poly(e) {
+    return function(t) {
+      return Math.pow(t, e);
+    };
+  }
+  function d3_ease_sin(t) {
+    return 1 - Math.cos(t * halfπ);
+  }
+  function d3_ease_exp(t) {
+    return Math.pow(2, 10 * (t - 1));
+  }
+  function d3_ease_circle(t) {
+    return 1 - Math.sqrt(1 - t * t);
+  }
+  function d3_ease_elastic(a, p) {
+    var s;
+    if (arguments.length < 2) p = .45;
+    if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4;
+    return function(t) {
+      return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p);
+    };
+  }
+  function d3_ease_back(s) {
+    if (!s) s = 1.70158;
+    return function(t) {
+      return t * t * ((s + 1) * t - s);
+    };
+  }
+  function d3_ease_bounce(t) {
+    return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
+  }
+  d3.interpolateHcl = d3_interpolateHcl;
+  function d3_interpolateHcl(a, b) {
+    a = d3.hcl(a);
+    b = d3.hcl(b);
+    var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al;
+    if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac;
+    if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+    return function(t) {
+      return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + "";
+    };
+  }
+  d3.interpolateHsl = d3_interpolateHsl;
+  function d3_interpolateHsl(a, b) {
+    a = d3.hsl(a);
+    b = d3.hsl(b);
+    var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;
+    if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as;
+    if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+    return function(t) {
+      return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + "";
+    };
+  }
+  d3.interpolateLab = d3_interpolateLab;
+  function d3_interpolateLab(a, b) {
+    a = d3.lab(a);
+    b = d3.lab(b);
+    var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab;
+    return function(t) {
+      return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + "";
+    };
+  }
+  d3.interpolateRound = d3_interpolateRound;
+  function d3_interpolateRound(a, b) {
+    b -= a;
+    return function(t) {
+      return Math.round(a + b * t);
+    };
+  }
+  d3.transform = function(string) {
+    var g = d3_document.createElementNS(d3.ns.prefix.svg, "g");
+    return (d3.transform = function(string) {
+      if (string != null) {
+        g.setAttribute("transform", string);
+        var t = g.transform.baseVal.consolidate();
+      }
+      return new d3_transform(t ? t.matrix : d3_transformIdentity);
+    })(string);
+  };
+  function d3_transform(m) {
+    var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
+    if (r0[0] * r1[1] < r1[0] * r0[1]) {
+      r0[0] *= -1;
+      r0[1] *= -1;
+      kx *= -1;
+      kz *= -1;
+    }
+    this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
+    this.translate = [ m.e, m.f ];
+    this.scale = [ kx, ky ];
+    this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
+  }
+  d3_transform.prototype.toString = function() {
+    return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
+  };
+  function d3_transformDot(a, b) {
+    return a[0] * b[0] + a[1] * b[1];
+  }
+  function d3_transformNormalize(a) {
+    var k = Math.sqrt(d3_transformDot(a, a));
+    if (k) {
+      a[0] /= k;
+      a[1] /= k;
+    }
+    return k;
+  }
+  function d3_transformCombine(a, b, k) {
+    a[0] += k * b[0];
+    a[1] += k * b[1];
+    return a;
+  }
+  var d3_transformIdentity = {
+    a: 1,
+    b: 0,
+    c: 0,
+    d: 1,
+    e: 0,
+    f: 0
+  };
+  d3.interpolateTransform = d3_interpolateTransform;
+  function d3_interpolateTransformPop(s) {
+    return s.length ? s.pop() + "," : "";
+  }
+  function d3_interpolateTranslate(ta, tb, s, q) {
+    if (ta[0] !== tb[0] || ta[1] !== tb[1]) {
+      var i = s.push("translate(", null, ",", null, ")");
+      q.push({
+        i: i - 4,
+        x: d3_interpolateNumber(ta[0], tb[0])
+      }, {
+        i: i - 2,
+        x: d3_interpolateNumber(ta[1], tb[1])
+      });
+    } else if (tb[0] || tb[1]) {
+      s.push("translate(" + tb + ")");
+    }
+  }
+  function d3_interpolateRotate(ra, rb, s, q) {
+    if (ra !== rb) {
+      if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360;
+      q.push({
+        i: s.push(d3_interpolateTransformPop(s) + "rotate(", null, ")") - 2,
+        x: d3_interpolateNumber(ra, rb)
+      });
+    } else if (rb) {
+      s.push(d3_interpolateTransformPop(s) + "rotate(" + rb + ")");
+    }
+  }
+  function d3_interpolateSkew(wa, wb, s, q) {
+    if (wa !== wb) {
+      q.push({
+        i: s.push(d3_interpolateTransformPop(s) + "skewX(", null, ")") - 2,
+        x: d3_interpolateNumber(wa, wb)
+      });
+    } else if (wb) {
+      s.push(d3_interpolateTransformPop(s) + "skewX(" + wb + ")");
+    }
+  }
+  function d3_interpolateScale(ka, kb, s, q) {
+    if (ka[0] !== kb[0] || ka[1] !== kb[1]) {
+      var i = s.push(d3_interpolateTransformPop(s) + "scale(", null, ",", null, ")");
+      q.push({
+        i: i - 4,
+        x: d3_interpolateNumber(ka[0], kb[0])
+      }, {
+        i: i - 2,
+        x: d3_interpolateNumber(ka[1], kb[1])
+      });
+    } else if (kb[0] !== 1 || kb[1] !== 1) {
+      s.push(d3_interpolateTransformPop(s) + "scale(" + kb + ")");
+    }
+  }
+  function d3_interpolateTransform(a, b) {
+    var s = [], q = [];
+    a = d3.transform(a), b = d3.transform(b);
+    d3_interpolateTranslate(a.translate, b.translate, s, q);
+    d3_interpolateRotate(a.rotate, b.rotate, s, q);
+    d3_interpolateSkew(a.skew, b.skew, s, q);
+    d3_interpolateScale(a.scale, b.scale, s, q);
+    a = b = null;
+    return function(t) {
+      var i = -1, n = q.length, o;
+      while (++i < n) s[(o = q[i]).i] = o.x(t);
+      return s.join("");
+    };
+  }
+  function d3_uninterpolateNumber(a, b) {
+    b = (b -= a = +a) || 1 / b;
+    return function(x) {
+      return (x - a) / b;
+    };
+  }
+  function d3_uninterpolateClamp(a, b) {
+    b = (b -= a = +a) || 1 / b;
+    return function(x) {
+      return Math.max(0, Math.min(1, (x - a) / b));
+    };
+  }
+  d3.layout = {};
+  d3.layout.bundle = function() {
+    return function(links) {
+      var paths = [], i = -1, n = links.length;
+      while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
+      return paths;
+    };
+  };
+  function d3_layout_bundlePath(link) {
+    var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ];
+    while (start !== lca) {
+      start = start.parent;
+      points.push(start);
+    }
+    var k = points.length;
+    while (end !== lca) {
+      points.splice(k, 0, end);
+      end = end.parent;
+    }
+    return points;
+  }
+  function d3_layout_bundleAncestors(node) {
+    var ancestors = [], parent = node.parent;
+    while (parent != null) {
+      ancestors.push(node);
+      node = parent;
+      parent = parent.parent;
+    }
+    ancestors.push(node);
+    return ancestors;
+  }
+  function d3_layout_bundleLeastCommonAncestor(a, b) {
+    if (a === b) return a;
+    var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null;
+    while (aNode === bNode) {
+      sharedNode = aNode;
+      aNode = aNodes.pop();
+      bNode = bNodes.pop();
+    }
+    return sharedNode;
+  }
+  d3.layout.chord = function() {
+    var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;
+    function relayout() {
+      var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j;
+      chords = [];
+      groups = [];
+      k = 0, i = -1;
+      while (++i < n) {
+        x = 0, j = -1;
+        while (++j < n) {
+          x += matrix[i][j];
+        }
+        groupSums.push(x);
+        subgroupIndex.push(d3.range(n));
+        k += x;
+      }
+      if (sortGroups) {
+        groupIndex.sort(function(a, b) {
+          return sortGroups(groupSums[a], groupSums[b]);
+        });
+      }
+      if (sortSubgroups) {
+        subgroupIndex.forEach(function(d, i) {
+          d.sort(function(a, b) {
+            return sortSubgroups(matrix[i][a], matrix[i][b]);
+          });
+        });
+      }
+      k = (τ - padding * n) / k;
+      x = 0, i = -1;
+      while (++i < n) {
+        x0 = x, j = -1;
+        while (++j < n) {
+          var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;
+          subgroups[di + "-" + dj] = {
+            index: di,
+            subindex: dj,
+            startAngle: a0,
+            endAngle: a1,
+            value: v
+          };
+        }
+        groups[di] = {
+          index: di,
+          startAngle: x0,
+          endAngle: x,
+          value: groupSums[di]
+        };
+        x += padding;
+      }
+      i = -1;
+      while (++i < n) {
+        j = i - 1;
+        while (++j < n) {
+          var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i];
+          if (source.value || target.value) {
+            chords.push(source.value < target.value ? {
+              source: target,
+              target: source
+            } : {
+              source: source,
+              target: target
+            });
+          }
+        }
+      }
+      if (sortChords) resort();
+    }
+    function resort() {
+      chords.sort(function(a, b) {
+        return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2);
+      });
+    }
+    chord.matrix = function(x) {
+      if (!arguments.length) return matrix;
+      n = (matrix = x) && matrix.length;
+      chords = groups = null;
+      return chord;
+    };
+    chord.padding = function(x) {
+      if (!arguments.length) return padding;
+      padding = x;
+      chords = groups = null;
+      return chord;
+    };
+    chord.sortGroups = function(x) {
+      if (!arguments.length) return sortGroups;
+      sortGroups = x;
+      chords = groups = null;
+      return chord;
+    };
+    chord.sortSubgroups = function(x) {
+      if (!arguments.length) return sortSubgroups;
+      sortSubgroups = x;
+      chords = null;
+      return chord;
+    };
+    chord.sortChords = function(x) {
+      if (!arguments.length) return sortChords;
+      sortChords = x;
+      if (chords) resort();
+      return chord;
+    };
+    chord.chords = function() {
+      if (!chords) relayout();
+      return chords;
+    };
+    chord.groups = function() {
+      if (!groups) relayout();
+      return groups;
+    };
+    return chord;
+  };
+  d3.layout.force = function() {
+    var force = {}, event = d3.dispatch("start", "tick", "end"), timer, size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges;
+    function repulse(node) {
+      return function(quad, x1, _, x2) {
+        if (quad.point !== node) {
+          var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;
+          if (dw * dw / theta2 < dn) {
+            if (dn < chargeDistance2) {
+              var k = quad.charge / dn;
+              node.px -= dx * k;
+              node.py -= dy * k;
+            }
+            return true;
+          }
+          if (quad.point && dn && dn < chargeDistance2) {
+            var k = quad.pointCharge / dn;
+            node.px -= dx * k;
+            node.py -= dy * k;
+          }
+        }
+        return !quad.charge;
+      };
+    }
+    force.tick = function() {
+      if ((alpha *= .99) < .005) {
+        timer = null;
+        event.end({
+          type: "end",
+          alpha: alpha = 0
+        });
+        return true;
+      }
+      var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y;
+      for (i = 0; i < m; ++i) {
+        o = links[i];
+        s = o.source;
+        t = o.target;
+        x = t.x - s.x;
+        y = t.y - s.y;
+        if (l = x * x + y * y) {
+          l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l;
+          x *= l;
+          y *= l;
+          t.x -= x * (k = s.weight + t.weight ? s.weight / (s.weight + t.weight) : .5);
+          t.y -= y * k;
+          s.x += x * (k = 1 - k);
+          s.y += y * k;
+        }
+      }
+      if (k = alpha * gravity) {
+        x = size[0] / 2;
+        y = size[1] / 2;
+        i = -1;
+        if (k) while (++i < n) {
+          o = nodes[i];
+          o.x += (x - o.x) * k;
+          o.y += (y - o.y) * k;
+        }
+      }
+      if (charge) {
+        d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges);
+        i = -1;
+        while (++i < n) {
+          if (!(o = nodes[i]).fixed) {
+            q.visit(repulse(o));
+          }
+        }
+      }
+      i = -1;
+      while (++i < n) {
+        o = nodes[i];
+        if (o.fixed) {
+          o.x = o.px;
+          o.y = o.py;
+        } else {
+          o.x -= (o.px - (o.px = o.x)) * friction;
+          o.y -= (o.py - (o.py = o.y)) * friction;
+        }
+      }
+      event.tick({
+        type: "tick",
+        alpha: alpha
+      });
+    };
+    force.nodes = function(x) {
+      if (!arguments.length) return nodes;
+      nodes = x;
+      return force;
+    };
+    force.links = function(x) {
+      if (!arguments.length) return links;
+      links = x;
+      return force;
+    };
+    force.size = function(x) {
+      if (!arguments.length) return size;
+      size = x;
+      return force;
+    };
+    force.linkDistance = function(x) {
+      if (!arguments.length) return linkDistance;
+      linkDistance = typeof x === "function" ? x : +x;
+      return force;
+    };
+    force.distance = force.linkDistance;
+    force.linkStrength = function(x) {
+      if (!arguments.length) return linkStrength;
+      linkStrength = typeof x === "function" ? x : +x;
+      return force;
+    };
+    force.friction = function(x) {
+      if (!arguments.length) return friction;
+      friction = +x;
+      return force;
+    };
+    force.charge = function(x) {
+      if (!arguments.length) return charge;
+      charge = typeof x === "function" ? x : +x;
+      return force;
+    };
+    force.chargeDistance = function(x) {
+      if (!arguments.length) return Math.sqrt(chargeDistance2);
+      chargeDistance2 = x * x;
+      return force;
+    };
+    force.gravity = function(x) {
+      if (!arguments.length) return gravity;
+      gravity = +x;
+      return force;
+    };
+    force.theta = function(x) {
+      if (!arguments.length) return Math.sqrt(theta2);
+      theta2 = x * x;
+      return force;
+    };
+    force.alpha = function(x) {
+      if (!arguments.length) return alpha;
+      x = +x;
+      if (alpha) {
+        if (x > 0) {
+          alpha = x;
+        } else {
+          timer.c = null, timer.t = NaN, timer = null;
+          event.end({
+            type: "end",
+            alpha: alpha = 0
+          });
+        }
+      } else if (x > 0) {
+        event.start({
+          type: "start",
+          alpha: alpha = x
+        });
+        timer = d3_timer(force.tick);
+      }
+      return force;
+    };
+    force.start = function() {
+      var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o;
+      for (i = 0; i < n; ++i) {
+        (o = nodes[i]).index = i;
+        o.weight = 0;
+      }
+      for (i = 0; i < m; ++i) {
+        o = links[i];
+        if (typeof o.source == "number") o.source = nodes[o.source];
+        if (typeof o.target == "number") o.target = nodes[o.target];
+        ++o.source.weight;
+        ++o.target.weight;
+      }
+      for (i = 0; i < n; ++i) {
+        o = nodes[i];
+        if (isNaN(o.x)) o.x = position("x", w);
+        if (isNaN(o.y)) o.y = position("y", h);
+        if (isNaN(o.px)) o.px = o.x;
+        if (isNaN(o.py)) o.py = o.y;
+      }
+      distances = [];
+      if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance;
+      strengths = [];
+      if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength;
+      charges = [];
+      if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge;
+      function position(dimension, size) {
+        if (!neighbors) {
+          neighbors = new Array(n);
+          for (j = 0; j < n; ++j) {
+            neighbors[j] = [];
+          }
+          for (j = 0; j < m; ++j) {
+            var o = links[j];
+            neighbors[o.source.index].push(o.target);
+            neighbors[o.target.index].push(o.source);
+          }
+        }
+        var candidates = neighbors[i], j = -1, l = candidates.length, x;
+        while (++j < l) if (!isNaN(x = candidates[j][dimension])) return x;
+        return Math.random() * size;
+      }
+      return force.resume();
+    };
+    force.resume = function() {
+      return force.alpha(.1);
+    };
+    force.stop = function() {
+      return force.alpha(0);
+    };
+    force.drag = function() {
+      if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend);
+      if (!arguments.length) return drag;
+      this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag);
+    };
+    function dragmove(d) {
+      d.px = d3.event.x, d.py = d3.event.y;
+      force.resume();
+    }
+    return d3.rebind(force, event, "on");
+  };
+  function d3_layout_forceDragstart(d) {
+    d.fixed |= 2;
+  }
+  function d3_layout_forceDragend(d) {
+    d.fixed &= ~6;
+  }
+  function d3_layout_forceMouseover(d) {
+    d.fixed |= 4;
+    d.px = d.x, d.py = d.y;
+  }
+  function d3_layout_forceMouseout(d) {
+    d.fixed &= ~4;
+  }
+  function d3_layout_forceAccumulate(quad, alpha, charges) {
+    var cx = 0, cy = 0;
+    quad.charge = 0;
+    if (!quad.leaf) {
+      var nodes = quad.nodes, n = nodes.length, i = -1, c;
+      while (++i < n) {
+        c = nodes[i];
+        if (c == null) continue;
+        d3_layout_forceAccumulate(c, alpha, charges);
+        quad.charge += c.charge;
+        cx += c.charge * c.cx;
+        cy += c.charge * c.cy;
+      }
+    }
+    if (quad.point) {
+      if (!quad.leaf) {
+        quad.point.x += Math.random() - .5;
+        quad.point.y += Math.random() - .5;
+      }
+      var k = alpha * charges[quad.point.index];
+      quad.charge += quad.pointCharge = k;
+      cx += k * quad.point.x;
+      cy += k * quad.point.y;
+    }
+    quad.cx = cx / quad.charge;
+    quad.cy = cy / quad.charge;
+  }
+  var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity;
+  d3.layout.hierarchy = function() {
+    var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue;
+    function hierarchy(root) {
+      var stack = [ root ], nodes = [], node;
+      root.depth = 0;
+      while ((node = stack.pop()) != null) {
+        nodes.push(node);
+        if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) {
+          var n, childs, child;
+          while (--n >= 0) {
+            stack.push(child = childs[n]);
+            child.parent = node;
+            child.depth = node.depth + 1;
+          }
+          if (value) node.value = 0;
+          node.children = childs;
+        } else {
+          if (value) node.value = +value.call(hierarchy, node, node.depth) || 0;
+          delete node.children;
+        }
+      }
+      d3_layout_hierarchyVisitAfter(root, function(node) {
+        var childs, parent;
+        if (sort && (childs = node.children)) childs.sort(sort);
+        if (value && (parent = node.parent)) parent.value += node.value;
+      });
+      return nodes;
+    }
+    hierarchy.sort = function(x) {
+      if (!arguments.length) return sort;
+      sort = x;
+      return hierarchy;
+    };
+    hierarchy.children = function(x) {
+      if (!arguments.length) return children;
+      children = x;
+      return hierarchy;
+    };
+    hierarchy.value = function(x) {
+      if (!arguments.length) return value;
+      value = x;
+      return hierarchy;
+    };
+    hierarchy.revalue = function(root) {
+      if (value) {
+        d3_layout_hierarchyVisitBefore(root, function(node) {
+          if (node.children) node.value = 0;
+        });
+        d3_layout_hierarchyVisitAfter(root, function(node) {
+          var parent;
+          if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0;
+          if (parent = node.parent) parent.value += node.value;
+        });
+      }
+      return root;
+    };
+    return hierarchy;
+  };
+  function d3_layout_hierarchyRebind(object, hierarchy) {
+    d3.rebind(object, hierarchy, "sort", "children", "value");
+    object.nodes = object;
+    object.links = d3_layout_hierarchyLinks;
+    return object;
+  }
+  function d3_layout_hierarchyVisitBefore(node, callback) {
+    var nodes = [ node ];
+    while ((node = nodes.pop()) != null) {
+      callback(node);
+      if ((children = node.children) && (n = children.length)) {
+        var n, children;
+        while (--n >= 0) nodes.push(children[n]);
+      }
+    }
+  }
+  function d3_layout_hierarchyVisitAfter(node, callback) {
+    var nodes = [ node ], nodes2 = [];
+    while ((node = nodes.pop()) != null) {
+      nodes2.push(node);
+      if ((children = node.children) && (n = children.length)) {
+        var i = -1, n, children;
+        while (++i < n) nodes.push(children[i]);
+      }
+    }
+    while ((node = nodes2.pop()) != null) {
+      callback(node);
+    }
+  }
+  function d3_layout_hierarchyChildren(d) {
+    return d.children;
+  }
+  function d3_layout_hierarchyValue(d) {
+    return d.value;
+  }
+  function d3_layout_hierarchySort(a, b) {
+    return b.value - a.value;
+  }
+  function d3_layout_hierarchyLinks(nodes) {
+    return d3.merge(nodes.map(function(parent) {
+      return (parent.children || []).map(function(child) {
+        return {
+          source: parent,
+          target: child
+        };
+      });
+    }));
+  }
+  d3.layout.partition = function() {
+    var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ];
+    function position(node, x, dx, dy) {
+      var children = node.children;
+      node.x = x;
+      node.y = node.depth * dy;
+      node.dx = dx;
+      node.dy = dy;
+      if (children && (n = children.length)) {
+        var i = -1, n, c, d;
+        dx = node.value ? dx / node.value : 0;
+        while (++i < n) {
+          position(c = children[i], x, d = c.value * dx, dy);
+          x += d;
+        }
+      }
+    }
+    function depth(node) {
+      var children = node.children, d = 0;
+      if (children && (n = children.length)) {
+        var i = -1, n;
+        while (++i < n) d = Math.max(d, depth(children[i]));
+      }
+      return 1 + d;
+    }
+    function partition(d, i) {
+      var nodes = hierarchy.call(this, d, i);
+      position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
+      return nodes;
+    }
+    partition.size = function(x) {
+      if (!arguments.length) return size;
+      size = x;
+      return partition;
+    };
+    return d3_layout_hierarchyRebind(partition, hierarchy);
+  };
+  d3.layout.pie = function() {
+    var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;
+    function pie(data) {
+      var n = data.length, values = data.map(function(d, i) {
+        return +value.call(pie, d, i);
+      }), a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a, p = Math.min(Math.abs(da) / n, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa = p * (da < 0 ? -1 : 1), sum = d3.sum(values), k = sum ? (da - n * pa) / sum : 0, index = d3.range(n), arcs = [], v;
+      if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) {
+        return values[j] - values[i];
+      } : function(i, j) {
+        return sort(data[i], data[j]);
+      });
+      index.forEach(function(i) {
+        arcs[i] = {
+          data: data[i],
+          value: v = values[i],
+          startAngle: a,
+          endAngle: a += v * k + pa,
+          padAngle: p
+        };
+      });
+      return arcs;
+    }
+    pie.value = function(_) {
+      if (!arguments.length) return value;
+      value = _;
+      return pie;
+    };
+    pie.sort = function(_) {
+      if (!arguments.length) return sort;
+      sort = _;
+      return pie;
+    };
+    pie.startAngle = function(_) {
+      if (!arguments.length) return startAngle;
+      startAngle = _;
+      return pie;
+    };
+    pie.endAngle = function(_) {
+      if (!arguments.length) return endAngle;
+      endAngle = _;
+      return pie;
+    };
+    pie.padAngle = function(_) {
+      if (!arguments.length) return padAngle;
+      padAngle = _;
+      return pie;
+    };
+    return pie;
+  };
+  var d3_layout_pieSortByValue = {};
+  d3.layout.stack = function() {
+    var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY;
+    function stack(data, index) {
+      if (!(n = data.length)) return data;
+      var series = data.map(function(d, i) {
+        return values.call(stack, d, i);
+      });
+      var points = series.map(function(d) {
+        return d.map(function(v, i) {
+          return [ x.call(stack, v, i), y.call(stack, v, i) ];
+        });
+      });
+      var orders = order.call(stack, points, index);
+      series = d3.permute(series, orders);
+      points = d3.permute(points, orders);
+      var offsets = offset.call(stack, points, index);
+      var m = series[0].length, n, i, j, o;
+      for (j = 0; j < m; ++j) {
+        out.call(stack, series[0][j], o = offsets[j], points[0][j][1]);
+        for (i = 1; i < n; ++i) {
+          out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]);
+        }
+      }
+      return data;
+    }
+    stack.values = function(x) {
+      if (!arguments.length) return values;
+      values = x;
+      return stack;
+    };
+    stack.order = function(x) {
+      if (!arguments.length) return order;
+      order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault;
+      return stack;
+    };
+    stack.offset = function(x) {
+      if (!arguments.length) return offset;
+      offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero;
+      return stack;
+    };
+    stack.x = function(z) {
+      if (!arguments.length) return x;
+      x = z;
+      return stack;
+    };
+    stack.y = function(z) {
+      if (!arguments.length) return y;
+      y = z;
+      return stack;
+    };
+    stack.out = function(z) {
+      if (!arguments.length) return out;
+      out = z;
+      return stack;
+    };
+    return stack;
+  };
+  function d3_layout_stackX(d) {
+    return d.x;
+  }
+  function d3_layout_stackY(d) {
+    return d.y;
+  }
+  function d3_layout_stackOut(d, y0, y) {
+    d.y0 = y0;
+    d.y = y;
+  }
+  var d3_layout_stackOrders = d3.map({
+    "inside-out": function(data) {
+      var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) {
+        return max[a] - max[b];
+      }), top = 0, bottom = 0, tops = [], bottoms = [];
+      for (i = 0; i < n; ++i) {
+        j = index[i];
+        if (top < bottom) {
+          top += sums[j];
+          tops.push(j);
+        } else {
+          bottom += sums[j];
+          bottoms.push(j);
+        }
+      }
+      return bottoms.reverse().concat(tops);
+    },
+    reverse: function(data) {
+      return d3.range(data.length).reverse();
+    },
+    "default": d3_layout_stackOrderDefault
+  });
+  var d3_layout_stackOffsets = d3.map({
+    silhouette: function(data) {
+      var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = [];
+      for (j = 0; j < m; ++j) {
+        for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+        if (o > max) max = o;
+        sums.push(o);
+      }
+      for (j = 0; j < m; ++j) {
+        y0[j] = (max - sums[j]) / 2;
+      }
+      return y0;
+    },
+    wiggle: function(data) {
+      var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = [];
+      y0[0] = o = o0 = 0;
+      for (j = 1; j < m; ++j) {
+        for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1];
+        for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) {
+          for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) {
+            s3 += (data[k][j][1] - data[k][j - 1][1]) / dx;
+          }
+          s2 += s3 * data[i][j][1];
+        }
+        y0[j] = o -= s1 ? s2 / s1 * dx : 0;
+        if (o < o0) o0 = o;
+      }
+      for (j = 0; j < m; ++j) y0[j] -= o0;
+      return y0;
+    },
+    expand: function(data) {
+      var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = [];
+      for (j = 0; j < m; ++j) {
+        for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+        if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k;
+      }
+      for (j = 0; j < m; ++j) y0[j] = 0;
+      return y0;
+    },
+    zero: d3_layout_stackOffsetZero
+  });
+  function d3_layout_stackOrderDefault(data) {
+    return d3.range(data.length);
+  }
+  function d3_layout_stackOffsetZero(data) {
+    var j = -1, m = data[0].length, y0 = [];
+    while (++j < m) y0[j] = 0;
+    return y0;
+  }
+  function d3_layout_stackMaxIndex(array) {
+    var i = 1, j = 0, v = array[0][1], k, n = array.length;
+    for (;i < n; ++i) {
+      if ((k = array[i][1]) > v) {
+        j = i;
+        v = k;
+      }
+    }
+    return j;
+  }
+  function d3_layout_stackReduceSum(d) {
+    return d.reduce(d3_layout_stackSum, 0);
+  }
+  function d3_layout_stackSum(p, d) {
+    return p + d[1];
+  }
+  d3.layout.histogram = function() {
+    var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges;
+    function histogram(data, i) {
+      var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x;
+      while (++i < m) {
+        bin = bins[i] = [];
+        bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]);
+        bin.y = 0;
+      }
+      if (m > 0) {
+        i = -1;
+        while (++i < n) {
+          x = values[i];
+          if (x >= range[0] && x <= range[1]) {
+            bin = bins[d3.bisect(thresholds, x, 1, m) - 1];
+            bin.y += k;
+            bin.push(data[i]);
+          }
+        }
+      }
+      return bins;
+    }
+    histogram.value = function(x) {
+      if (!arguments.length) return valuer;
+      valuer = x;
+      return histogram;
+    };
+    histogram.range = function(x) {
+      if (!arguments.length) return ranger;
+      ranger = d3_functor(x);
+      return histogram;
+    };
+    histogram.bins = function(x) {
+      if (!arguments.length) return binner;
+      binner = typeof x === "number" ? function(range) {
+        return d3_layout_histogramBinFixed(range, x);
+      } : d3_functor(x);
+      return histogram;
+    };
+    histogram.frequency = function(x) {
+      if (!arguments.length) return frequency;
+      frequency = !!x;
+      return histogram;
+    };
+    return histogram;
+  };
+  function d3_layout_histogramBinSturges(range, values) {
+    return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1));
+  }
+  function d3_layout_histogramBinFixed(range, n) {
+    var x = -1, b = +range[0], m = (range[1] - b) / n, f = [];
+    while (++x <= n) f[x] = m * x + b;
+    return f;
+  }
+  function d3_layout_histogramRange(values) {
+    return [ d3.min(values), d3.max(values) ];
+  }
+  d3.layout.pack = function() {
+    var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius;
+    function pack(d, i) {
+      var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() {
+        return radius;
+      };
+      root.x = root.y = 0;
+      d3_layout_hierarchyVisitAfter(root, function(d) {
+        d.r = +r(d.value);
+      });
+      d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+      if (padding) {
+        var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2;
+        d3_layout_hierarchyVisitAfter(root, function(d) {
+          d.r += dr;
+        });
+        d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+        d3_layout_hierarchyVisitAfter(root, function(d) {
+          d.r -= dr;
+        });
+      }
+      d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h));
+      return nodes;
+    }
+    pack.size = function(_) {
+      if (!arguments.length) return size;
+      size = _;
+      return pack;
+    };
+    pack.radius = function(_) {
+      if (!arguments.length) return radius;
+      radius = _ == null || typeof _ === "function" ? _ : +_;
+      return pack;
+    };
+    pack.padding = function(_) {
+      if (!arguments.length) return padding;
+      padding = +_;
+      return pack;
+    };
+    return d3_layout_hierarchyRebind(pack, hierarchy);
+  };
+  function d3_layout_packSort(a, b) {
+    return a.value - b.value;
+  }
+  function d3_layout_packInsert(a, b) {
+    var c = a._pack_next;
+    a._pack_next = b;
+    b._pack_prev = a;
+    b._pack_next = c;
+    c._pack_prev = b;
+  }
+  function d3_layout_packSplice(a, b) {
+    a._pack_next = b;
+    b._pack_prev = a;
+  }
+  function d3_layout_packIntersects(a, b) {
+    var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r;
+    return .999 * dr * dr > dx * dx + dy * dy;
+  }
+  function d3_layout_packSiblings(node) {
+    if (!(nodes = node.children) || !(n = nodes.length)) return;
+    var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n;
+    function bound(node) {
+      xMin = Math.min(node.x - node.r, xMin);
+      xMax = Math.max(node.x + node.r, xMax);
+      yMin = Math.min(node.y - node.r, yMin);
+      yMax = Math.max(node.y + node.r, yMax);
+    }
+    nodes.forEach(d3_layout_packLink);
+    a = nodes[0];
+    a.x = -a.r;
+    a.y = 0;
+    bound(a);
+    if (n > 1) {
+      b = nodes[1];
+      b.x = b.r;
+      b.y = 0;
+      bound(b);
+      if (n > 2) {
+        c = nodes[2];
+        d3_layout_packPlace(a, b, c);
+        bound(c);
+        d3_layout_packInsert(a, c);
+        a._pack_prev = c;
+        d3_layout_packInsert(c, b);
+        b = a._pack_next;
+        for (i = 3; i < n; i++) {
+          d3_layout_packPlace(a, b, c = nodes[i]);
+          var isect = 0, s1 = 1, s2 = 1;
+          for (j = b._pack_next; j !== b; j = j._pack_next, s1++) {
+            if (d3_layout_packIntersects(j, c)) {
+              isect = 1;
+              break;
+            }
+          }
+          if (isect == 1) {
+            for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) {
+              if (d3_layout_packIntersects(k, c)) {
+                break;
+              }
+            }
+          }
+          if (isect) {
+            if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b);
+            i--;
+          } else {
+            d3_layout_packInsert(a, c);
+            b = c;
+            bound(c);
+          }
+        }
+      }
+    }
+    var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0;
+    for (i = 0; i < n; i++) {
+      c = nodes[i];
+      c.x -= cx;
+      c.y -= cy;
+      cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y));
+    }
+    node.r = cr;
+    nodes.forEach(d3_layout_packUnlink);
+  }
+  function d3_layout_packLink(node) {
+    node._pack_next = node._pack_prev = node;
+  }
+  function d3_layout_packUnlink(node) {
+    delete node._pack_next;
+    delete node._pack_prev;
+  }
+  function d3_layout_packTransform(node, x, y, k) {
+    var children = node.children;
+    node.x = x += k * node.x;
+    node.y = y += k * node.y;
+    node.r *= k;
+    if (children) {
+      var i = -1, n = children.length;
+      while (++i < n) d3_layout_packTransform(children[i], x, y, k);
+    }
+  }
+  function d3_layout_packPlace(a, b, c) {
+    var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y;
+    if (db && (dx || dy)) {
+      var da = b.r + c.r, dc = dx * dx + dy * dy;
+      da *= da;
+      db *= db;
+      var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);
+      c.x = a.x + x * dx + y * dy;
+      c.y = a.y + x * dy - y * dx;
+    } else {
+      c.x = a.x + db;
+      c.y = a.y;
+    }
+  }
+  d3.layout.tree = function() {
+    var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null;
+    function tree(d, i) {
+      var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0);
+      d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
+      d3_layout_hierarchyVisitBefore(root1, secondWalk);
+      if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else {
+        var left = root0, right = root0, bottom = root0;
+        d3_layout_hierarchyVisitBefore(root0, function(node) {
+          if (node.x < left.x) left = node;
+          if (node.x > right.x) right = node;
+          if (node.depth > bottom.depth) bottom = node;
+        });
+        var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1);
+        d3_layout_hierarchyVisitBefore(root0, function(node) {
+          node.x = (node.x + tx) * kx;
+          node.y = node.depth * ky;
+        });
+      }
+      return nodes;
+    }
+    function wrapTree(root0) {
+      var root1 = {
+        A: null,
+        children: [ root0 ]
+      }, queue = [ root1 ], node1;
+      while ((node1 = queue.pop()) != null) {
+        for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) {
+          queue.push((children[i] = child = {
+            _: children[i],
+            parent: node1,
+            children: (child = children[i].children) && child.slice() || [],
+            A: null,
+            a: null,
+            z: 0,
+            m: 0,
+            c: 0,
+            s: 0,
+            t: null,
+            i: i
+          }).a = child);
+        }
+      }
+      return root1.children[0];
+    }
+    function firstWalk(v) {
+      var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
+      if (children.length) {
+        d3_layout_treeShift(v);
+        var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+        if (w) {
+          v.z = w.z + separation(v._, w._);
+          v.m = v.z - midpoint;
+        } else {
+          v.z = midpoint;
+        }
+      } else if (w) {
+        v.z = w.z + separation(v._, w._);
+      }
+      v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+    }
+    function secondWalk(v) {
+      v._.x = v.z + v.parent.m;
+      v.m += v.parent.m;
+    }
+    function apportion(v, w, ancestor) {
+      if (w) {
+        var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+        while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
+          vom = d3_layout_treeLeft(vom);
+          vop = d3_layout_treeRight(vop);
+          vop.a = v;
+          shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+          if (shift > 0) {
+            d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift);
+            sip += shift;
+            sop += shift;
+          }
+          sim += vim.m;
+          sip += vip.m;
+          som += vom.m;
+          sop += vop.m;
+        }
+        if (vim && !d3_layout_treeRight(vop)) {
+          vop.t = vim;
+          vop.m += sim - sop;
+        }
+        if (vip && !d3_layout_treeLeft(vom)) {
+          vom.t = vip;
+          vom.m += sip - som;
+          ancestor = v;
+        }
+      }
+      return ancestor;
+    }
+    function sizeNode(node) {
+      node.x *= size[0];
+      node.y = node.depth * size[1];
+    }
+    tree.separation = function(x) {
+      if (!arguments.length) return separation;
+      separation = x;
+      return tree;
+    };
+    tree.size = function(x) {
+      if (!arguments.length) return nodeSize ? null : size;
+      nodeSize = (size = x) == null ? sizeNode : null;
+      return tree;
+    };
+    tree.nodeSize = function(x) {
+      if (!arguments.length) return nodeSize ? size : null;
+      nodeSize = (size = x) == null ? null : sizeNode;
+      return tree;
+    };
+    return d3_layout_hierarchyRebind(tree, hierarchy);
+  };
+  function d3_layout_treeSeparation(a, b) {
+    return a.parent == b.parent ? 1 : 2;
+  }
+  function d3_layout_treeLeft(v) {
+    var children = v.children;
+    return children.length ? children[0] : v.t;
+  }
+  function d3_layout_treeRight(v) {
+    var children = v.children, n;
+    return (n = children.length) ? children[n - 1] : v.t;
+  }
+  function d3_layout_treeMove(wm, wp, shift) {
+    var change = shift / (wp.i - wm.i);
+    wp.c -= change;
+    wp.s += shift;
+    wm.c += change;
+    wp.z += shift;
+    wp.m += shift;
+  }
+  function d3_layout_treeShift(v) {
+    var shift = 0, change = 0, children = v.children, i = children.length, w;
+    while (--i >= 0) {
+      w = children[i];
+      w.z += shift;
+      w.m += shift;
+      shift += w.s + (change += w.c);
+    }
+  }
+  function d3_layout_treeAncestor(vim, v, ancestor) {
+    return vim.a.parent === v.parent ? vim.a : ancestor;
+  }
+  d3.layout.cluster = function() {
+    var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false;
+    function cluster(d, i) {
+      var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0;
+      d3_layout_hierarchyVisitAfter(root, function(node) {
+        var children = node.children;
+        if (children && children.length) {
+          node.x = d3_layout_clusterX(children);
+          node.y = d3_layout_clusterY(children);
+        } else {
+          node.x = previousNode ? x += separation(node, previousNode) : 0;
+          node.y = 0;
+          previousNode = node;
+        }
+      });
+      var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+      d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) {
+        node.x = (node.x - root.x) * size[0];
+        node.y = (root.y - node.y) * size[1];
+      } : function(node) {
+        node.x = (node.x - x0) / (x1 - x0) * size[0];
+        node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1];
+      });
+      return nodes;
+    }
+    cluster.separation = function(x) {
+      if (!arguments.length) return separation;
+      separation = x;
+      return cluster;
+    };
+    cluster.size = function(x) {
+      if (!arguments.length) return nodeSize ? null : size;
+      nodeSize = (size = x) == null;
+      return cluster;
+    };
+    cluster.nodeSize = function(x) {
+      if (!arguments.length) return nodeSize ? size : null;
+      nodeSize = (size = x) != null;
+      return cluster;
+    };
+    return d3_layout_hierarchyRebind(cluster, hierarchy);
+  };
+  function d3_layout_clusterY(children) {
+    return 1 + d3.max(children, function(child) {
+      return child.y;
+    });
+  }
+  function d3_layout_clusterX(children) {
+    return children.reduce(function(x, child) {
+      return x + child.x;
+    }, 0) / children.length;
+  }
+  function d3_layout_clusterLeft(node) {
+    var children = node.children;
+    return children && children.length ? d3_layout_clusterLeft(children[0]) : node;
+  }
+  function d3_layout_clusterRight(node) {
+    var children = node.children, n;
+    return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node;
+  }
+  d3.layout.treemap = function() {
+    var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5));
+    function scale(children, k) {
+      var i = -1, n = children.length, child, area;
+      while (++i < n) {
+        area = (child = children[i]).value * (k < 0 ? 0 : k);
+        child.area = isNaN(area) || area <= 0 ? 0 : area;
+      }
+    }
+    function squarify(node) {
+      var children = node.children;
+      if (children && children.length) {
+        var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n;
+        scale(remaining, rect.dx * rect.dy / node.value);
+        row.area = 0;
+        while ((n = remaining.length) > 0) {
+          row.push(child = remaining[n - 1]);
+          row.area += child.area;
+          if (mode !== "squarify" || (score = worst(row, u)) <= best) {
+            remaining.pop();
+            best = score;
+          } else {
+            row.area -= row.pop().area;
+            position(row, u, rect, false);
+            u = Math.min(rect.dx, rect.dy);
+            row.length = row.area = 0;
+            best = Infinity;
+          }
+        }
+        if (row.length) {
+          position(row, u, rect, true);
+          row.length = row.area = 0;
+        }
+        children.forEach(squarify);
+      }
+    }
+    function stickify(node) {
+      var children = node.children;
+      if (children && children.length) {
+        var rect = pad(node), remaining = children.slice(), child, row = [];
+        scale(remaining, rect.dx * rect.dy / node.value);
+        row.area = 0;
+        while (child = remaining.pop()) {
+          row.push(child);
+          row.area += child.area;
+          if (child.z != null) {
+            position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
+            row.length = row.area = 0;
+          }
+        }
+        children.forEach(stickify);
+      }
+    }
+    function worst(row, u) {
+      var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length;
+      while (++i < n) {
+        if (!(r = row[i].area)) continue;
+        if (r < rmin) rmin = r;
+        if (r > rmax) rmax = r;
+      }
+      s *= s;
+      u *= u;
+      return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity;
+    }
+    function position(row, u, rect, flush) {
+      var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o;
+      if (u == rect.dx) {
+        if (flush || v > rect.dy) v = rect.dy;
+        while (++i < n) {
+          o = row[i];
+          o.x = x;
+          o.y = y;
+          o.dy = v;
+          x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0);
+        }
+        o.z = true;
+        o.dx += rect.x + rect.dx - x;
+        rect.y += v;
+        rect.dy -= v;
+      } else {
+        if (flush || v > rect.dx) v = rect.dx;
+        while (++i < n) {
+          o = row[i];
+          o.x = x;
+          o.y = y;
+          o.dx = v;
+          y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0);
+        }
+        o.z = false;
+        o.dy += rect.y + rect.dy - y;
+        rect.x += v;
+        rect.dx -= v;
+      }
+    }
+    function treemap(d) {
+      var nodes = stickies || hierarchy(d), root = nodes[0];
+      root.x = root.y = 0;
+      if (root.value) root.dx = size[0], root.dy = size[1]; else root.dx = root.dy = 0;
+      if (stickies) hierarchy.revalue(root);
+      scale([ root ], root.dx * root.dy / root.value);
+      (stickies ? stickify : squarify)(root);
+      if (sticky) stickies = nodes;
+      return nodes;
+    }
+    treemap.size = function(x) {
+      if (!arguments.length) return size;
+      size = x;
+      return treemap;
+    };
+    treemap.padding = function(x) {
+      if (!arguments.length) return padding;
+      function padFunction(node) {
+        var p = x.call(treemap, node, node.depth);
+        return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p);
+      }
+      function padConstant(node) {
+        return d3_layout_treemapPad(node, x);
+      }
+      var type;
+      pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ], 
+      padConstant) : padConstant;
+      return treemap;
+    };
+    treemap.round = function(x) {
+      if (!arguments.length) return round != Number;
+      round = x ? Math.round : Number;
+      return treemap;
+    };
+    treemap.sticky = function(x) {
+      if (!arguments.length) return sticky;
+      sticky = x;
+      stickies = null;
+      return treemap;
+    };
+    treemap.ratio = function(x) {
+      if (!arguments.length) return ratio;
+      ratio = x;
+      return treemap;
+    };
+    treemap.mode = function(x) {
+      if (!arguments.length) return mode;
+      mode = x + "";
+      return treemap;
+    };
+    return d3_layout_hierarchyRebind(treemap, hierarchy);
+  };
+  function d3_layout_treemapPadNull(node) {
+    return {
+      x: node.x,
+      y: node.y,
+      dx: node.dx,
+      dy: node.dy
+    };
+  }
+  function d3_layout_treemapPad(node, padding) {
+    var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2];
+    if (dx < 0) {
+      x += dx / 2;
+      dx = 0;
+    }
+    if (dy < 0) {
+      y += dy / 2;
+      dy = 0;
+    }
+    return {
+      x: x,
+      y: y,
+      dx: dx,
+      dy: dy
+    };
+  }
+  d3.random = {
+    normal: function(µ, σ) {
+      var n = arguments.length;
+      if (n < 2) σ = 1;
+      if (n < 1) µ = 0;
+      return function() {
+        var x, y, r;
+        do {
+          x = Math.random() * 2 - 1;
+          y = Math.random() * 2 - 1;
+          r = x * x + y * y;
+        } while (!r || r > 1);
+        return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r);
+      };
+    },
+    logNormal: function() {
+      var random = d3.random.normal.apply(d3, arguments);
+      return function() {
+        return Math.exp(random());
+      };
+    },
+    bates: function(m) {
+      var random = d3.random.irwinHall(m);
+      return function() {
+        return random() / m;
+      };
+    },
+    irwinHall: function(m) {
+      return function() {
+        for (var s = 0, j = 0; j < m; j++) s += Math.random();
+        return s;
+      };
+    }
+  };
+  d3.scale = {};
+  function d3_scaleExtent(domain) {
+    var start = domain[0], stop = domain[domain.length - 1];
+    return start < stop ? [ start, stop ] : [ stop, start ];
+  }
+  function d3_scaleRange(scale) {
+    return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
+  }
+  function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
+    var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]);
+    return function(x) {
+      return i(u(x));
+    };
+  }
+  function d3_scale_nice(domain, nice) {
+    var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx;
+    if (x1 < x0) {
+      dx = i0, i0 = i1, i1 = dx;
+      dx = x0, x0 = x1, x1 = dx;
+    }
+    domain[i0] = nice.floor(x0);
+    domain[i1] = nice.ceil(x1);
+    return domain;
+  }
+  function d3_scale_niceStep(step) {
+    return step ? {
+      floor: function(x) {
+        return Math.floor(x / step) * step;
+      },
+      ceil: function(x) {
+        return Math.ceil(x / step) * step;
+      }
+    } : d3_scale_niceIdentity;
+  }
+  var d3_scale_niceIdentity = {
+    floor: d3_identity,
+    ceil: d3_identity
+  };
+  function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
+    var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1;
+    if (domain[k] < domain[0]) {
+      domain = domain.slice().reverse();
+      range = range.slice().reverse();
+    }
+    while (++j <= k) {
+      u.push(uninterpolate(domain[j - 1], domain[j]));
+      i.push(interpolate(range[j - 1], range[j]));
+    }
+    return function(x) {
+      var j = d3.bisect(domain, x, 1, k) - 1;
+      return i[j](u[j](x));
+    };
+  }
+  d3.scale.linear = function() {
+    return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false);
+  };
+  function d3_scale_linear(domain, range, interpolate, clamp) {
+    var output, input;
+    function rescale() {
+      var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
+      output = linear(domain, range, uninterpolate, interpolate);
+      input = linear(range, domain, uninterpolate, d3_interpolate);
+      return scale;
+    }
+    function scale(x) {
+      return output(x);
+    }
+    scale.invert = function(y) {
+      return input(y);
+    };
+    scale.domain = function(x) {
+      if (!arguments.length) return domain;
+      domain = x.map(Number);
+      return rescale();
+    };
+    scale.range = function(x) {
+      if (!arguments.length) return range;
+      range = x;
+      return rescale();
+    };
+    scale.rangeRound = function(x) {
+      return scale.range(x).interpolate(d3_interpolateRound);
+    };
+    scale.clamp = function(x) {
+      if (!arguments.length) return clamp;
+      clamp = x;
+      return rescale();
+    };
+    scale.interpolate = function(x) {
+      if (!arguments.length) return interpolate;
+      interpolate = x;
+      return rescale();
+    };
+    scale.ticks = function(m) {
+      return d3_scale_linearTicks(domain, m);
+    };
+    scale.tickFormat = function(m, format) {
+      return d3_scale_linearTickFormat(domain, m, format);
+    };
+    scale.nice = function(m) {
+      d3_scale_linearNice(domain, m);
+      return rescale();
+    };
+    scale.copy = function() {
+      return d3_scale_linear(domain, range, interpolate, clamp);
+    };
+    return rescale();
+  }
+  function d3_scale_linearRebind(scale, linear) {
+    return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");
+  }
+  function d3_scale_linearNice(domain, m) {
+    d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+    d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+    return domain;
+  }
+  function d3_scale_linearTickRange(domain, m) {
+    if (m == null) m = 10;
+    var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step;
+    if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2;
+    extent[0] = Math.ceil(extent[0] / step) * step;
+    extent[1] = Math.floor(extent[1] / step) * step + step * .5;
+    extent[2] = step;
+    return extent;
+  }
+  function d3_scale_linearTicks(domain, m) {
+    return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
+  }
+  function d3_scale_linearTickFormat(domain, m, format) {
+    var range = d3_scale_linearTickRange(domain, m);
+    if (format) {
+      var match = d3_format_re.exec(format);
+      match.shift();
+      if (match[8] === "s") {
+        var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1])));
+        if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2]));
+        match[8] = "f";
+        format = d3.format(match.join(""));
+        return function(d) {
+          return format(prefix.scale(d)) + prefix.symbol;
+        };
+      }
+      if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range);
+      format = match.join("");
+    } else {
+      format = ",." + d3_scale_linearPrecision(range[2]) + "f";
+    }
+    return d3.format(format);
+  }
+  var d3_scale_linearFormatSignificant = {
+    s: 1,
+    g: 1,
+    p: 1,
+    r: 1,
+    e: 1
+  };
+  function d3_scale_linearPrecision(value) {
+    return -Math.floor(Math.log(value) / Math.LN10 + .01);
+  }
+  function d3_scale_linearFormatPrecision(type, range) {
+    var p = d3_scale_linearPrecision(range[2]);
+    return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2;
+  }
+  d3.scale.log = function() {
+    return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]);
+  };
+  function d3_scale_log(linear, base, positive, domain) {
+    function log(x) {
+      return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
+    }
+    function pow(x) {
+      return positive ? Math.pow(base, x) : -Math.pow(base, -x);
+    }
+    function scale(x) {
+      return linear(log(x));
+    }
+    scale.invert = function(x) {
+      return pow(linear.invert(x));
+    };
+    scale.domain = function(x) {
+      if (!arguments.length) return domain;
+      positive = x[0] >= 0;
+      linear.domain((domain = x.map(Number)).map(log));
+      return scale;
+    };
+    scale.base = function(_) {
+      if (!arguments.length) return base;
+      base = +_;
+      linear.domain(domain.map(log));
+      return scale;
+    };
+    scale.nice = function() {
+      var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative);
+      linear.domain(niced);
+      domain = niced.map(pow);
+      return scale;
+    };
+    scale.ticks = function() {
+      var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base;
+      if (isFinite(j - i)) {
+        if (positive) {
+          for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k);
+          ticks.push(pow(i));
+        } else {
+          ticks.push(pow(i));
+          for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k);
+        }
+        for (i = 0; ticks[i] < u; i++) {}
+        for (j = ticks.length; ticks[j - 1] > v; j--) {}
+        ticks = ticks.slice(i, j);
+      }
+      return ticks;
+    };
+    scale.tickFormat = function(n, format) {
+      if (!arguments.length) return d3_scale_logFormat;
+      if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format);
+      var k = Math.max(1, base * n / scale.ticks().length);
+      return function(d) {
+        var i = d / pow(Math.round(log(d)));
+        if (i * base < base - .5) i *= base;
+        return i <= k ? format(d) : "";
+      };
+    };
+    scale.copy = function() {
+      return d3_scale_log(linear.copy(), base, positive, domain);
+    };
+    return d3_scale_linearRebind(scale, linear);
+  }
+  var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = {
+    floor: function(x) {
+      return -Math.ceil(-x);
+    },
+    ceil: function(x) {
+      return -Math.floor(-x);
+    }
+  };
+  d3.scale.pow = function() {
+    return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]);
+  };
+  function d3_scale_pow(linear, exponent, domain) {
+    var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent);
+    function scale(x) {
+      return linear(powp(x));
+    }
+    scale.invert = function(x) {
+      return powb(linear.invert(x));
+    };
+    scale.domain = function(x) {
+      if (!arguments.length) return domain;
+      linear.domain((domain = x.map(Number)).map(powp));
+      return scale;
+    };
+    scale.ticks = function(m) {
+      return d3_scale_linearTicks(domain, m);
+    };
+    scale.tickFormat = function(m, format) {
+      return d3_scale_linearTickFormat(domain, m, format);
+    };
+    scale.nice = function(m) {
+      return scale.domain(d3_scale_linearNice(domain, m));
+    };
+    scale.exponent = function(x) {
+      if (!arguments.length) return exponent;
+      powp = d3_scale_powPow(exponent = x);
+      powb = d3_scale_powPow(1 / exponent);
+      linear.domain(domain.map(powp));
+      return scale;
+    };
+    scale.copy = function() {
+      return d3_scale_pow(linear.copy(), exponent, domain);
+    };
+    return d3_scale_linearRebind(scale, linear);
+  }
+  function d3_scale_powPow(e) {
+    return function(x) {
+      return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
+    };
+  }
+  d3.scale.sqrt = function() {
+    return d3.scale.pow().exponent(.5);
+  };
+  d3.scale.ordinal = function() {
+    return d3_scale_ordinal([], {
+      t: "range",
+      a: [ [] ]
+    });
+  };
+  function d3_scale_ordinal(domain, ranger) {
+    var index, range, rangeBand;
+    function scale(x) {
+      return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length];
+    }
+    function steps(start, step) {
+      return d3.range(domain.length).map(function(i) {
+        return start + step * i;
+      });
+    }
+    scale.domain = function(x) {
+      if (!arguments.length) return domain;
+      domain = [];
+      index = new d3_Map();
+      var i = -1, n = x.length, xi;
+      while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi));
+      return scale[ranger.t].apply(scale, ranger.a);
+    };
+    scale.range = function(x) {
+      if (!arguments.length) return range;
+      range = x;
+      rangeBand = 0;
+      ranger = {
+        t: "range",
+        a: arguments
+      };
+      return scale;
+    };
+    scale.rangePoints = function(x, padding) {
+      if (arguments.length < 2) padding = 0;
+      var start = x[0], stop = x[1], step = domain.length < 2 ? (start = (start + stop) / 2, 
+      0) : (stop - start) / (domain.length - 1 + padding);
+      range = steps(start + step * padding / 2, step);
+      rangeBand = 0;
+      ranger = {
+        t: "rangePoints",
+        a: arguments
+      };
+      return scale;
+    };
+    scale.rangeRoundPoints = function(x, padding) {
+      if (arguments.length < 2) padding = 0;
+      var start = x[0], stop = x[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2), 
+      0) : (stop - start) / (domain.length - 1 + padding) | 0;
+      range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
+      rangeBand = 0;
+      ranger = {
+        t: "rangeRoundPoints",
+        a: arguments
+      };
+      return scale;
+    };
+    scale.rangeBands = function(x, padding, outerPadding) {
+      if (arguments.length < 2) padding = 0;
+      if (arguments.length < 3) outerPadding = padding;
+      var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding);
+      range = steps(start + step * outerPadding, step);
+      if (reverse) range.reverse();
+      rangeBand = step * (1 - padding);
+      ranger = {
+        t: "rangeBands",
+        a: arguments
+      };
+      return scale;
+    };
+    scale.rangeRoundBands = function(x, padding, outerPadding) {
+      if (arguments.length < 2) padding = 0;
+      if (arguments.length < 3) outerPadding = padding;
+      var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
+      range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);
+      if (reverse) range.reverse();
+      rangeBand = Math.round(step * (1 - padding));
+      ranger = {
+        t: "rangeRoundBands",
+        a: arguments
+      };
+      return scale;
+    };
+    scale.rangeBand = function() {
+      return rangeBand;
+    };
+    scale.rangeExtent = function() {
+      return d3_scaleExtent(ranger.a[0]);
+    };
+    scale.copy = function() {
+      return d3_scale_ordinal(domain, ranger);
+    };
+    return scale.domain(domain);
+  }
+  d3.scale.category10 = function() {
+    return d3.scale.ordinal().range(d3_category10);
+  };
+  d3.scale.category20 = function() {
+    return d3.scale.ordinal().range(d3_category20);
+  };
+  d3.scale.category20b = function() {
+    return d3.scale.ordinal().range(d3_category20b);
+  };
+  d3.scale.category20c = function() {
+    return d3.scale.ordinal().range(d3_category20c);
+  };
+  var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString);
+  var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString);
+  var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString);
+  var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString);
+  d3.scale.quantile = function() {
+    return d3_scale_quantile([], []);
+  };
+  function d3_scale_quantile(domain, range) {
+    var thresholds;
+    function rescale() {
+      var k = 0, q = range.length;
+      thresholds = [];
+      while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+      return scale;
+    }
+    function scale(x) {
+      if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
+    }
+    scale.domain = function(x) {
+      if (!arguments.length) return domain;
+      domain = x.map(d3_number).filter(d3_numeric).sort(d3_ascending);
+      return rescale();
+    };
+    scale.range = function(x) {
+      if (!arguments.length) return range;
+      range = x;
+      return rescale();
+    };
+    scale.quantiles = function() {
+      return thresholds;
+    };
+    scale.invertExtent = function(y) {
+      y = range.indexOf(y);
+      return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ];
+    };
+    scale.copy = function() {
+      return d3_scale_quantile(domain, range);
+    };
+    return rescale();
+  }
+  d3.scale.quantize = function() {
+    return d3_scale_quantize(0, 1, [ 0, 1 ]);
+  };
+  function d3_scale_quantize(x0, x1, range) {
+    var kx, i;
+    function scale(x) {
+      return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
+    }
+    function rescale() {
+      kx = range.length / (x1 - x0);
+      i = range.length - 1;
+      return scale;
+    }
+    scale.domain = function(x) {
+      if (!arguments.length) return [ x0, x1 ];
+      x0 = +x[0];
+      x1 = +x[x.length - 1];
+      return rescale();
+    };
+    scale.range = function(x) {
+      if (!arguments.length) return range;
+      range = x;
+      return rescale();
+    };
+    scale.invertExtent = function(y) {
+      y = range.indexOf(y);
+      y = y < 0 ? NaN : y / kx + x0;
+      return [ y, y + 1 / kx ];
+    };
+    scale.copy = function() {
+      return d3_scale_quantize(x0, x1, range);
+    };
+    return rescale();
+  }
+  d3.scale.threshold = function() {
+    return d3_scale_threshold([ .5 ], [ 0, 1 ]);
+  };
+  function d3_scale_threshold(domain, range) {
+    function scale(x) {
+      if (x <= x) return range[d3.bisect(domain, x)];
+    }
+    scale.domain = function(_) {
+      if (!arguments.length) return domain;
+      domain = _;
+      return scale;
+    };
+    scale.range = function(_) {
+      if (!arguments.length) return range;
+      range = _;
+      return scale;
+    };
+    scale.invertExtent = function(y) {
+      y = range.indexOf(y);
+      return [ domain[y - 1], domain[y] ];
+    };
+    scale.copy = function() {
+      return d3_scale_threshold(domain, range);
+    };
+    return scale;
+  }
+  d3.scale.identity = function() {
+    return d3_scale_identity([ 0, 1 ]);
+  };
+  function d3_scale_identity(domain) {
+    function identity(x) {
+      return +x;
+    }
+    identity.invert = identity;
+    identity.domain = identity.range = function(x) {
+      if (!arguments.length) return domain;
+      domain = x.map(identity);
+      return identity;
+    };
+    identity.ticks = function(m) {
+      return d3_scale_linearTicks(domain, m);
+    };
+    identity.tickFormat = function(m, format) {
+      return d3_scale_linearTickFormat(domain, m, format);
+    };
+    identity.copy = function() {
+      return d3_scale_identity(domain);
+    };
+    return identity;
+  }
+  d3.svg = {};
+  function d3_zero() {
+    return 0;
+  }
+  d3.svg.arc = function() {
+    var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle;
+    function arc() {
+      var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1;
+      if (r1 < r0) rc = r1, r1 = r0, r0 = rc;
+      if (da >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
+      var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
+      if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
+        rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);
+        if (!cw) p1 *= -1;
+        if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap));
+        if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap));
+      }
+      if (r1) {
+        x0 = r1 * Math.cos(a0 + p1);
+        y0 = r1 * Math.sin(a0 + p1);
+        x1 = r1 * Math.cos(a1 - p1);
+        y1 = r1 * Math.sin(a1 - p1);
+        var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1;
+        if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
+          var h1 = (a0 + a1) / 2;
+          x0 = r1 * Math.cos(h1);
+          y0 = r1 * Math.sin(h1);
+          x1 = y1 = null;
+        }
+      } else {
+        x0 = y0 = 0;
+      }
+      if (r0) {
+        x2 = r0 * Math.cos(a1 - p0);
+        y2 = r0 * Math.sin(a1 - p0);
+        x3 = r0 * Math.cos(a0 + p0);
+        y3 = r0 * Math.sin(a0 + p0);
+        var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1;
+        if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
+          var h0 = (a0 + a1) / 2;
+          x2 = r0 * Math.cos(h0);
+          y2 = r0 * Math.sin(h0);
+          x3 = y3 = null;
+        }
+      } else {
+        x2 = y2 = 0;
+      }
+      if (da > ε && (rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) {
+        cr = r0 < r1 ^ cw ? 0 : 1;
+        var rc1 = rc, rc0 = rc;
+        if (da < π) {
+          var oc = x3 == null ? [ x2, y2 ] : x1 == null ? [ x0, y0 ] : d3_geom_polygonIntersect([ x0, y0 ], [ x3, y3 ], [ x1, y1 ], [ x2, y2 ]), ax = x0 - oc[0], ay = y0 - oc[1], bx = x1 - oc[0], by = y1 - oc[1], kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+          rc0 = Math.min(rc, (r0 - lc) / (kc - 1));
+          rc1 = Math.min(rc, (r1 - lc) / (kc + 1));
+        }
+        if (x1 != null) {
+          var t30 = d3_svg_arcCornerTangents(x3 == null ? [ x2, y2 ] : [ x3, y3 ], [ x0, y0 ], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([ x1, y1 ], [ x2, y2 ], r1, rc1, cw);
+          if (rc === rc1) {
+            path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
+          } else {
+            path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
+          }
+        } else {
+          path.push("M", x0, ",", y0);
+        }
+        if (x3 != null) {
+          var t03 = d3_svg_arcCornerTangents([ x0, y0 ], [ x3, y3 ], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([ x2, y2 ], x1 == null ? [ x0, y0 ] : [ x1, y1 ], r0, -rc0, cw);
+          if (rc === rc0) {
+            path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+          } else {
+            path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+          }
+        } else {
+          path.push("L", x2, ",", y2);
+        }
+      } else {
+        path.push("M", x0, ",", y0);
+        if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
+        path.push("L", x2, ",", y2);
+        if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
+      }
+      path.push("Z");
+      return path.join("");
+    }
+    function circleSegment(r1, cw) {
+      return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
+    }
+    arc.innerRadius = function(v) {
+      if (!arguments.length) return innerRadius;
+      innerRadius = d3_functor(v);
+      return arc;
+    };
+    arc.outerRadius = function(v) {
+      if (!arguments.length) return outerRadius;
+      outerRadius = d3_functor(v);
+      return arc;
+    };
+    arc.cornerRadius = function(v) {
+      if (!arguments.length) return cornerRadius;
+      cornerRadius = d3_functor(v);
+      return arc;
+    };
+    arc.padRadius = function(v) {
+      if (!arguments.length) return padRadius;
+      padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v);
+      return arc;
+    };
+    arc.startAngle = function(v) {
+      if (!arguments.length) return startAngle;
+      startAngle = d3_functor(v);
+      return arc;
+    };
+    arc.endAngle = function(v) {
+      if (!arguments.length) return endAngle;
+      endAngle = d3_functor(v);
+      return arc;
+    };
+    arc.padAngle = function(v) {
+      if (!arguments.length) return padAngle;
+      padAngle = d3_functor(v);
+      return arc;
+    };
+    arc.centroid = function() {
+      var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ;
+      return [ Math.cos(a) * r, Math.sin(a) * r ];
+    };
+    return arc;
+  };
+  var d3_svg_arcAuto = "auto";
+  function d3_svg_arcInnerRadius(d) {
+    return d.innerRadius;
+  }
+  function d3_svg_arcOuterRadius(d) {
+    return d.outerRadius;
+  }
+  function d3_svg_arcStartAngle(d) {
+    return d.startAngle;
+  }
+  function d3_svg_arcEndAngle(d) {
+    return d.endAngle;
+  }
+  function d3_svg_arcPadAngle(d) {
+    return d && d.padAngle;
+  }
+  function d3_svg_arcSweep(x0, y0, x1, y1) {
+    return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
+  }
+  function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
+    var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r = r1 - rc, D = x1 * y2 - x2 * y1, d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x3, dy0 = cy0 - y3, dx1 = cx1 - x3, dy1 = cy1 - y3;
+    if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+    return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ];
+  }
+  function d3_svg_line(projection) {
+    var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7;
+    function line(data) {
+      var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y);
+      function segment() {
+        segments.push("M", interpolate(projection(points), tension));
+      }
+      while (++i < n) {
+        if (defined.call(this, d = data[i], i)) {
+          points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]);
+        } else if (points.length) {
+          segment();
+          points = [];
+        }
+      }
+      if (points.length) segment();
+      return segments.length ? segments.join("") : null;
+    }
+    line.x = function(_) {
+      if (!arguments.length) return x;
+      x = _;
+      return line;
+    };
+    line.y = function(_) {
+      if (!arguments.length) return y;
+      y = _;
+      return line;
+    };
+    line.defined = function(_) {
+      if (!arguments.length) return defined;
+      defined = _;
+      return line;
+    };
+    line.interpolate = function(_) {
+      if (!arguments.length) return interpolateKey;
+      if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+      return line;
+    };
+    line.tension = function(_) {
+      if (!arguments.length) return tension;
+      tension = _;
+      return line;
+    };
+    return line;
+  }
+  d3.svg.line = function() {
+    return d3_svg_line(d3_identity);
+  };
+  var d3_svg_lineInterpolators = d3.map({
+    linear: d3_svg_lineLinear,
+    "linear-closed": d3_svg_lineLinearClosed,
+    step: d3_svg_lineStep,
+    "step-before": d3_svg_lineStepBefore,
+    "step-after": d3_svg_lineStepAfter,
+    basis: d3_svg_lineBasis,
+    "basis-open": d3_svg_lineBasisOpen,
+    "basis-closed": d3_svg_lineBasisClosed,
+    bundle: d3_svg_lineBundle,
+    cardinal: d3_svg_lineCardinal,
+    "cardinal-open": d3_svg_lineCardinalOpen,
+    "cardinal-closed": d3_svg_lineCardinalClosed,
+    monotone: d3_svg_lineMonotone
+  });
+  d3_svg_lineInterpolators.forEach(function(key, value) {
+    value.key = key;
+    value.closed = /-closed$/.test(key);
+  });
+  function d3_svg_lineLinear(points) {
+    return points.length > 1 ? points.join("L") : points + "Z";
+  }
+  function d3_svg_lineLinearClosed(points) {
+    return points.join("L") + "Z";
+  }
+  function d3_svg_lineStep(points) {
+    var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+    while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
+    if (n > 1) path.push("H", p[0]);
+    return path.join("");
+  }
+  function d3_svg_lineStepBefore(points) {
+    var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+    while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
+    return path.join("");
+  }
+  function d3_svg_lineStepAfter(points) {
+    var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+    while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
+    return path.join("");
+  }
+  function d3_svg_lineCardinalOpen(points, tension) {
+    return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
+  }
+  function d3_svg_lineCardinalClosed(points, tension) {
+    return points.length < 3 ? d3_svg_lineLinearClosed(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), 
+    points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension));
+  }
+  function d3_svg_lineCardinal(points, tension) {
+    return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
+  }
+  function d3_svg_lineHermite(points, tangents) {
+    if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
+      return d3_svg_lineLinear(points);
+    }
+    var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
+    if (quad) {
+      path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
+      p0 = points[1];
+      pi = 2;
+    }
+    if (tangents.length > 1) {
+      t = tangents[1];
+      p = points[pi];
+      pi++;
+      path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+      for (var i = 2; i < tangents.length; i++, pi++) {
+        p = points[pi];
+        t = tangents[i];
+        path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+      }
+    }
+    if (quad) {
+      var lp = points[pi];
+      path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
+    }
+    return path;
+  }
+  function d3_svg_lineCardinalTangents(points, tension) {
+    var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length;
+    while (++i < n) {
+      p0 = p1;
+      p1 = p2;
+      p2 = points[i];
+      tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]);
+    }
+    return tangents;
+  }
+  function d3_svg_lineBasis(points) {
+    if (points.length < 3) return d3_svg_lineLinear(points);
+    var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+    points.push(points[n - 1]);
+    while (++i <= n) {
+      pi = points[i];
+      px.shift();
+      px.push(pi[0]);
+      py.shift();
+      py.push(pi[1]);
+      d3_svg_lineBasisBezier(path, px, py);
+    }
+    points.pop();
+    path.push("L", pi);
+    return path.join("");
+  }
+  function d3_svg_lineBasisOpen(points) {
+    if (points.length < 4) return d3_svg_lineLinear(points);
+    var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
+    while (++i < 3) {
+      pi = points[i];
+      px.push(pi[0]);
+      py.push(pi[1]);
+    }
+    path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
+    --i;
+    while (++i < n) {
+      pi = points[i];
+      px.shift();
+      px.push(pi[0]);
+      py.shift();
+      py.push(pi[1]);
+      d3_svg_lineBasisBezier(path, px, py);
+    }
+    return path.join("");
+  }
+  function d3_svg_lineBasisClosed(points) {
+    var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
+    while (++i < 4) {
+      pi = points[i % n];
+      px.push(pi[0]);
+      py.push(pi[1]);
+    }
+    path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+    --i;
+    while (++i < m) {
+      pi = points[i % n];
+      px.shift();
+      px.push(pi[0]);
+      py.shift();
+      py.push(pi[1]);
+      d3_svg_lineBasisBezier(path, px, py);
+    }
+    return path.join("");
+  }
+  function d3_svg_lineBundle(points, tension) {
+    var n = points.length - 1;
+    if (n) {
+      var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t;
+      while (++i <= n) {
+        p = points[i];
+        t = i / n;
+        p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
+        p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
+      }
+    }
+    return d3_svg_lineBasis(points);
+  }
+  function d3_svg_lineDot4(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+  }
+  var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ];
+  function d3_svg_lineBasisBezier(path, x, y) {
+    path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
+  }
+  function d3_svg_lineSlope(p0, p1) {
+    return (p1[1] - p0[1]) / (p1[0] - p0[0]);
+  }
+  function d3_svg_lineFiniteDifferences(points) {
+    var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1);
+    while (++i < j) {
+      m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2;
+    }
+    m[i] = d;
+    return m;
+  }
+  function d3_svg_lineMonotoneTangents(points) {
+    var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1;
+    while (++i < j) {
+      d = d3_svg_lineSlope(points[i], points[i + 1]);
+      if (abs(d) < ε) {
+        m[i] = m[i + 1] = 0;
+      } else {
+        a = m[i] / d;
+        b = m[i + 1] / d;
+        s = a * a + b * b;
+        if (s > 9) {
+          s = d * 3 / Math.sqrt(s);
+          m[i] = s * a;
+          m[i + 1] = s * b;
+        }
+      }
+    }
+    i = -1;
+    while (++i <= j) {
+      s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i]));
+      tangents.push([ s || 0, m[i] * s || 0 ]);
+    }
+    return tangents;
+  }
+  function d3_svg_lineMonotone(points) {
+    return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
+  }
+  d3.svg.line.radial = function() {
+    var line = d3_svg_line(d3_svg_lineRadial);
+    line.radius = line.x, delete line.x;
+    line.angle = line.y, delete line.y;
+    return line;
+  };
+  function d3_svg_lineRadial(points) {
+    var point, i = -1, n = points.length, r, a;
+    while (++i < n) {
+      point = points[i];
+      r = point[0];
+      a = point[1] - halfπ;
+      point[0] = r * Math.cos(a);
+      point[1] = r * Math.sin(a);
+    }
+    return points;
+  }
+  function d3_svg_area(projection) {
+    var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7;
+    function area(data) {
+      var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() {
+        return x;
+      } : d3_functor(x1), fy1 = y0 === y1 ? function() {
+        return y;
+      } : d3_functor(y1), x, y;
+      function segment() {
+        segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z");
+      }
+      while (++i < n) {
+        if (defined.call(this, d = data[i], i)) {
+          points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]);
+          points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]);
+        } else if (points0.length) {
+          segment();
+          points0 = [];
+          points1 = [];
+        }
+      }
+      if (points0.length) segment();
+      return segments.length ? segments.join("") : null;
+    }
+    area.x = function(_) {
+      if (!arguments.length) return x1;
+      x0 = x1 = _;
+      return area;
+    };
+    area.x0 = function(_) {
+      if (!arguments.length) return x0;
+      x0 = _;
+      return area;
+    };
+    area.x1 = function(_) {
+      if (!arguments.length) return x1;
+      x1 = _;
+      return area;
+    };
+    area.y = function(_) {
+      if (!arguments.length) return y1;
+      y0 = y1 = _;
+      return area;
+    };
+    area.y0 = function(_) {
+      if (!arguments.length) return y0;
+      y0 = _;
+      return area;
+    };
+    area.y1 = function(_) {
+      if (!arguments.length) return y1;
+      y1 = _;
+      return area;
+    };
+    area.defined = function(_) {
+      if (!arguments.length) return defined;
+      defined = _;
+      return area;
+    };
+    area.interpolate = function(_) {
+      if (!arguments.length) return interpolateKey;
+      if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+      interpolateReverse = interpolate.reverse || interpolate;
+      L = interpolate.closed ? "M" : "L";
+      return area;
+    };
+    area.tension = function(_) {
+      if (!arguments.length) return tension;
+      tension = _;
+      return area;
+    };
+    return area;
+  }
+  d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
+  d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
+  d3.svg.area = function() {
+    return d3_svg_area(d3_identity);
+  };
+  d3.svg.area.radial = function() {
+    var area = d3_svg_area(d3_svg_lineRadial);
+    area.radius = area.x, delete area.x;
+    area.innerRadius = area.x0, delete area.x0;
+    area.outerRadius = area.x1, delete area.x1;
+    area.angle = area.y, delete area.y;
+    area.startAngle = area.y0, delete area.y0;
+    area.endAngle = area.y1, delete area.y1;
+    return area;
+  };
+  d3.svg.chord = function() {
+    var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle;
+    function chord(d, i) {
+      var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i);
+      return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z";
+    }
+    function subgroup(self, f, d, i) {
+      var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) - halfπ, a1 = endAngle.call(self, subgroup, i) - halfπ;
+      return {
+        r: r,
+        a0: a0,
+        a1: a1,
+        p0: [ r * Math.cos(a0), r * Math.sin(a0) ],
+        p1: [ r * Math.cos(a1), r * Math.sin(a1) ]
+      };
+    }
+    function equals(a, b) {
+      return a.a0 == b.a0 && a.a1 == b.a1;
+    }
+    function arc(r, p, a) {
+      return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p;
+    }
+    function curve(r0, p0, r1, p1) {
+      return "Q 0,0 " + p1;
+    }
+    chord.radius = function(v) {
+      if (!arguments.length) return radius;
+      radius = d3_functor(v);
+      return chord;
+    };
+    chord.source = function(v) {
+      if (!arguments.length) return source;
+      source = d3_functor(v);
+      return chord;
+    };
+    chord.target = function(v) {
+      if (!arguments.length) return target;
+      target = d3_functor(v);
+      return chord;
+    };
+    chord.startAngle = function(v) {
+      if (!arguments.length) return startAngle;
+      startAngle = d3_functor(v);
+      return chord;
+    };
+    chord.endAngle = function(v) {
+      if (!arguments.length) return endAngle;
+      endAngle = d3_functor(v);
+      return chord;
+    };
+    return chord;
+  };
+  function d3_svg_chordRadius(d) {
+    return d.radius;
+  }
+  d3.svg.diagonal = function() {
+    var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection;
+    function diagonal(d, i) {
+      var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, {
+        x: p0.x,
+        y: m
+      }, {
+        x: p3.x,
+        y: m
+      }, p3 ];
+      p = p.map(projection);
+      return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
+    }
+    diagonal.source = function(x) {
+      if (!arguments.length) return source;
+      source = d3_functor(x);
+      return diagonal;
+    };
+    diagonal.target = function(x) {
+      if (!arguments.length) return target;
+      target = d3_functor(x);
+      return diagonal;
+    };
+    diagonal.projection = function(x) {
+      if (!arguments.length) return projection;
+      projection = x;
+      return diagonal;
+    };
+    return diagonal;
+  };
+  function d3_svg_diagonalProjection(d) {
+    return [ d.x, d.y ];
+  }
+  d3.svg.diagonal.radial = function() {
+    var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection;
+    diagonal.projection = function(x) {
+      return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection;
+    };
+    return diagonal;
+  };
+  function d3_svg_diagonalRadialProjection(projection) {
+    return function() {
+      var d = projection.apply(this, arguments), r = d[0], a = d[1] - halfπ;
+      return [ r * Math.cos(a), r * Math.sin(a) ];
+    };
+  }
+  d3.svg.symbol = function() {
+    var type = d3_svg_symbolType, size = d3_svg_symbolSize;
+    function symbol(d, i) {
+      return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i));
+    }
+    symbol.type = function(x) {
+      if (!arguments.length) return type;
+      type = d3_functor(x);
+      return symbol;
+    };
+    symbol.size = function(x) {
+      if (!arguments.length) return size;
+      size = d3_functor(x);
+      return symbol;
+    };
+    return symbol;
+  };
+  function d3_svg_symbolSize() {
+    return 64;
+  }
+  function d3_svg_symbolType() {
+    return "circle";
+  }
+  function d3_svg_symbolCircle(size) {
+    var r = Math.sqrt(size / π);
+    return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z";
+  }
+  var d3_svg_symbols = d3.map({
+    circle: d3_svg_symbolCircle,
+    cross: function(size) {
+      var r = Math.sqrt(size / 5) / 2;
+      return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z";
+    },
+    diamond: function(size) {
+      var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30;
+      return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z";
+    },
+    square: function(size) {
+      var r = Math.sqrt(size) / 2;
+      return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z";
+    },
+    "triangle-down": function(size) {
+      var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+      return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z";
+    },
+    "triangle-up": function(size) {
+      var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+      return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z";
+    }
+  });
+  d3.svg.symbolTypes = d3_svg_symbols.keys();
+  var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians);
+  d3_selectionPrototype.transition = function(name) {
+    var id = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name), subgroups = [], subgroup, node, transition = d3_transitionInherit || {
+      time: Date.now(),
+      ease: d3_ease_cubicInOut,
+      delay: 0,
+      duration: 250
+    };
+    for (var j = -1, m = this.length; ++j < m; ) {
+      subgroups.push(subgroup = []);
+      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+        if (node = group[i]) d3_transitionNode(node, i, ns, id, transition);
+        subgroup.push(node);
+      }
+    }
+    return d3_transition(subgroups, ns, id);
+  };
+  d3_selectionPrototype.interrupt = function(name) {
+    return this.each(name == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name)));
+  };
+  var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
+  function d3_selection_interruptNS(ns) {
+    return function() {
+      var lock, activeId, active;
+      if ((lock = this[ns]) && (active = lock[activeId = lock.active])) {
+        active.timer.c = null;
+        active.timer.t = NaN;
+        if (--lock.count) delete lock[activeId]; else delete this[ns];
+        lock.active += .5;
+        active.event && active.event.interrupt.call(this, this.__data__, active.index);
+      }
+    };
+  }
+  function d3_transition(groups, ns, id) {
+    d3_subclass(groups, d3_transitionPrototype);
+    groups.namespace = ns;
+    groups.id = id;
+    return groups;
+  }
+  var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit;
+  d3_transitionPrototype.call = d3_selectionPrototype.call;
+  d3_transitionPrototype.empty = d3_selectionPrototype.empty;
+  d3_transitionPrototype.node = d3_selectionPrototype.node;
+  d3_transitionPrototype.size = d3_selectionPrototype.size;
+  d3.transition = function(selection, name) {
+    return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name) : selection : d3.selection().transition(selection);
+  };
+  d3.transition.prototype = d3_transitionPrototype;
+  d3_transitionPrototype.select = function(selector) {
+    var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node;
+    selector = d3_selection_selector(selector);
+    for (var j = -1, m = this.length; ++j < m; ) {
+      subgroups.push(subgroup = []);
+      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+        if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) {
+          if ("__data__" in node) subnode.__data__ = node.__data__;
+          d3_transitionNode(subnode, i, ns, id, node[ns][id]);
+          subgroup.push(subnode);
+        } else {
+          subgroup.push(null);
+        }
+      }
+    }
+    return d3_transition(subgroups, ns, id);
+  };
+  d3_transitionPrototype.selectAll = function(selector) {
+    var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition;
+    selector = d3_selection_selectorAll(selector);
+    for (var j = -1, m = this.length; ++j < m; ) {
+      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+        if (node = group[i]) {
+          transition = node[ns][id];
+          subnodes = selector.call(node, node.__data__, i, j);
+          subgroups.push(subgroup = []);
+          for (var k = -1, o = subnodes.length; ++k < o; ) {
+            if (subnode = subnodes[k]) d3_transitionNode(subnode, k, ns, id, transition);
+            subgroup.push(subnode);
+          }
+        }
+      }
+    }
+    return d3_transition(subgroups, ns, id);
+  };
+  d3_transitionPrototype.filter = function(filter) {
+    var subgroups = [], subgroup, group, node;
+    if (typeof filter !== "function") filter = d3_selection_filter(filter);
+    for (var j = 0, m = this.length; j < m; j++) {
+      subgroups.push(subgroup = []);
+      for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+        if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+          subgroup.push(node);
+        }
+      }
+    }
+    return d3_transition(subgroups, this.namespace, this.id);
+  };
+  d3_transitionPrototype.tween = function(name, tween) {
+    var id = this.id, ns = this.namespace;
+    if (arguments.length < 2) return this.node()[ns][id].tween.get(name);
+    return d3_selection_each(this, tween == null ? function(node) {
+      node[ns][id].tween.remove(name);
+    } : function(node) {
+      node[ns][id].tween.set(name, tween);
+    });
+  };
+  function d3_transition_tween(groups, name, value, tween) {
+    var id = groups.id, ns = groups.namespace;
+    return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) {
+      node[ns][id].tween.set(name, tween(value.call(node, node.__data__, i, j)));
+    } : (value = tween(value), function(node) {
+      node[ns][id].tween.set(name, value);
+    }));
+  }
+  d3_transitionPrototype.attr = function(nameNS, value) {
+    if (arguments.length < 2) {
+      for (value in nameNS) this.attr(value, nameNS[value]);
+      return this;
+    }
+    var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS);
+    function attrNull() {
+      this.removeAttribute(name);
+    }
+    function attrNullNS() {
+      this.removeAttributeNS(name.space, name.local);
+    }
+    function attrTween(b) {
+      return b == null ? attrNull : (b += "", function() {
+        var a = this.getAttribute(name), i;
+        return a !== b && (i = interpolate(a, b), function(t) {
+          this.setAttribute(name, i(t));
+        });
+      });
+    }
+    function attrTweenNS(b) {
+      return b == null ? attrNullNS : (b += "", function() {
+        var a = this.getAttributeNS(name.space, name.local), i;
+        return a !== b && (i = interpolate(a, b), function(t) {
+          this.setAttributeNS(name.space, name.local, i(t));
+        });
+      });
+    }
+    return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
+  };
+  d3_transitionPrototype.attrTween = function(nameNS, tween) {
+    var name = d3.ns.qualify(nameNS);
+    function attrTween(d, i) {
+      var f = tween.call(this, d, i, this.getAttribute(name));
+      return f && function(t) {
+        this.setAttribute(name, f(t));
+      };
+    }
+    function attrTweenNS(d, i) {
+      var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
+      return f && function(t) {
+        this.setAttributeNS(name.space, name.local, f(t));
+      };
+    }
+    return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
+  };
+  d3_transitionPrototype.style = function(name, value, priority) {
+    var n = arguments.length;
+    if (n < 3) {
+      if (typeof name !== "string") {
+        if (n < 2) value = "";
+        for (priority in name) this.style(priority, name[priority], value);
+        return this;
+      }
+      priority = "";
+    }
+    function styleNull() {
+      this.style.removeProperty(name);
+    }
+    function styleString(b) {
+      return b == null ? styleNull : (b += "", function() {
+        var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name), i;
+        return a !== b && (i = d3_interpolate(a, b), function(t) {
+          this.style.setProperty(name, i(t), priority);
+        });
+      });
+    }
+    return d3_transition_tween(this, "style." + name, value, styleString);
+  };
+  d3_transitionPrototype.styleTween = function(name, tween, priority) {
+    if (arguments.length < 3) priority = "";
+    function styleTween(d, i) {
+      var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name));
+      return f && function(t) {
+        this.style.setProperty(name, f(t), priority);
+      };
+    }
+    return this.tween("style." + name, styleTween);
+  };
+  d3_transitionPrototype.text = function(value) {
+    return d3_transition_tween(this, "text", value, d3_transition_text);
+  };
+  function d3_transition_text(b) {
+    if (b == null) b = "";
+    return function() {
+      this.textContent = b;
+    };
+  }
+  d3_transitionPrototype.remove = function() {
+    var ns = this.namespace;
+    return this.each("end.transition", function() {
+      var p;
+      if (this[ns].count < 2 && (p = this.parentNode)) p.removeChild(this);
+    });
+  };
+  d3_transitionPrototype.ease = function(value) {
+    var id = this.id, ns = this.namespace;
+    if (arguments.length < 1) return this.node()[ns][id].ease;
+    if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
+    return d3_selection_each(this, function(node) {
+      node[ns][id].ease = value;
+    });
+  };
+  d3_transitionPrototype.delay = function(value) {
+    var id = this.id, ns = this.namespace;
+    if (arguments.length < 1) return this.node()[ns][id].delay;
+    return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+      node[ns][id].delay = +value.call(node, node.__data__, i, j);
+    } : (value = +value, function(node) {
+      node[ns][id].delay = value;
+    }));
+  };
+  d3_transitionPrototype.duration = function(value) {
+    var id = this.id, ns = this.namespace;
+    if (arguments.length < 1) return this.node()[ns][id].duration;
+    return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+      node[ns][id].duration = Math.max(1, value.call(node, node.__data__, i, j));
+    } : (value = Math.max(1, value), function(node) {
+      node[ns][id].duration = value;
+    }));
+  };
+  d3_transitionPrototype.each = function(type, listener) {
+    var id = this.id, ns = this.namespace;
+    if (arguments.length < 2) {
+      var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId;
+      try {
+        d3_transitionInheritId = id;
+        d3_selection_each(this, function(node, i, j) {
+          d3_transitionInherit = node[ns][id];
+          type.call(node, node.__data__, i, j);
+        });
+      } finally {
+        d3_transitionInherit = inherit;
+        d3_transitionInheritId = inheritId;
+      }
+    } else {
+      d3_selection_each(this, function(node) {
+        var transition = node[ns][id];
+        (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener);
+      });
+    }
+    return this;
+  };
+  d3_transitionPrototype.transition = function() {
+    var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition;
+    for (var j = 0, m = this.length; j < m; j++) {
+      subgroups.push(subgroup = []);
+      for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+        if (node = group[i]) {
+          transition = node[ns][id0];
+          d3_transitionNode(node, i, ns, id1, {
+            time: transition.time,
+            ease: transition.ease,
+            delay: transition.delay + transition.duration,
+            duration: transition.duration
+          });
+        }
+        subgroup.push(node);
+      }
+    }
+    return d3_transition(subgroups, ns, id1);
+  };
+  function d3_transitionNamespace(name) {
+    return name == null ? "__transition__" : "__transition_" + name + "__";
+  }
+  function d3_transitionNode(node, i, ns, id, inherit) {
+    var lock = node[ns] || (node[ns] = {
+      active: 0,
+      count: 0
+    }), transition = lock[id], time, timer, duration, ease, tweens;
+    function schedule(elapsed) {
+      var delay = transition.delay;
+      timer.t = delay + time;
+      if (delay <= elapsed) return start(elapsed - delay);
+      timer.c = start;
+    }
+    function start(elapsed) {
+      var activeId = lock.active, active = lock[activeId];
+      if (active) {
+        active.timer.c = null;
+        active.timer.t = NaN;
+        --lock.count;
+        delete lock[activeId];
+        active.event && active.event.interrupt.call(node, node.__data__, active.index);
+      }
+      for (var cancelId in lock) {
+        if (+cancelId < id) {
+          var cancel = lock[cancelId];
+          cancel.timer.c = null;
+          cancel.timer.t = NaN;
+          --lock.count;
+          delete lock[cancelId];
+        }
+      }
+      timer.c = tick;
+      d3_timer(function() {
+        if (timer.c && tick(elapsed || 1)) {
+          timer.c = null;
+          timer.t = NaN;
+        }
+        return 1;
+      }, 0, time);
+      lock.active = id;
+      transition.event && transition.event.start.call(node, node.__data__, i);
+      tweens = [];
+      transition.tween.forEach(function(key, value) {
+        if (value = value.call(node, node.__data__, i)) {
+          tweens.push(value);
+        }
+      });
+      ease = transition.ease;
+      duration = transition.duration;
+    }
+    function tick(elapsed) {
+      var t = elapsed / duration, e = ease(t), n = tweens.length;
+      while (n > 0) {
+        tweens[--n].call(node, e);
+      }
+      if (t >= 1) {
+        transition.event && transition.event.end.call(node, node.__data__, i);
+        if (--lock.count) delete lock[id]; else delete node[ns];
+        return 1;
+      }
+    }
+    if (!transition) {
+      time = inherit.time;
+      timer = d3_timer(schedule, 0, time);
+      transition = lock[id] = {
+        tween: new d3_Map(),
+        time: time,
+        timer: timer,
+        delay: inherit.delay,
+        duration: inherit.duration,
+        ease: inherit.ease,
+        index: i
+      };
+      inherit = null;
+      ++lock.count;
+    }
+  }
+  d3.svg.axis = function() {
+    var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_;
+    function axis(g) {
+      g.each(function() {
+        var g = d3.select(this);
+        var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy();
+        var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickSpacing = Math.max(innerTickSize, 0) + tickPadding, tickTransform;
+        var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"), 
+        d3.transition(path));
+        tickEnter.append("line");
+        tickEnter.append("text");
+        var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2;
+        if (orient === "bottom" || orient === "top") {
+          tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2";
+          text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle");
+          pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize);
+        } else {
+          tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2";
+          text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start");
+          pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize);
+        }
+        lineEnter.attr(y2, sign * innerTickSize);
+        textEnter.attr(y1, sign * tickSpacing);
+        lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize);
+        textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing);
+        if (scale1.rangeBand) {
+          var x = scale1, dx = x.rangeBand() / 2;
+          scale0 = scale1 = function(d) {
+            return x(d) + dx;
+          };
+        } else if (scale0.rangeBand) {
+          scale0 = scale1;
+        } else {
+          tickExit.call(tickTransform, scale1, scale0);
+        }
+        tickEnter.call(tickTransform, scale0, scale1);
+        tickUpdate.call(tickTransform, scale1, scale1);
+      });
+    }
+    axis.scale = function(x) {
+      if (!arguments.length) return scale;
+      scale = x;
+      return axis;
+    };
+    axis.orient = function(x) {
+      if (!arguments.length) return orient;
+      orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient;
+      return axis;
+    };
+    axis.ticks = function() {
+      if (!arguments.length) return tickArguments_;
+      tickArguments_ = d3_array(arguments);
+      return axis;
+    };
+    axis.tickValues = function(x) {
+      if (!arguments.length) return tickValues;
+      tickValues = x;
+      return axis;
+    };
+    axis.tickFormat = function(x) {
+      if (!arguments.length) return tickFormat_;
+      tickFormat_ = x;
+      return axis;
+    };
+    axis.tickSize = function(x) {
+      var n = arguments.length;
+      if (!n) return innerTickSize;
+      innerTickSize = +x;
+      outerTickSize = +arguments[n - 1];
+      return axis;
+    };
+    axis.innerTickSize = function(x) {
+      if (!arguments.length) return innerTickSize;
+      innerTickSize = +x;
+      return axis;
+    };
+    axis.outerTickSize = function(x) {
+      if (!arguments.length) return outerTickSize;
+      outerTickSize = +x;
+      return axis;
+    };
+    axis.tickPadding = function(x) {
+      if (!arguments.length) return tickPadding;
+      tickPadding = +x;
+      return axis;
+    };
+    axis.tickSubdivide = function() {
+      return arguments.length && axis;
+    };
+    return axis;
+  };
+  var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = {
+    top: 1,
+    right: 1,
+    bottom: 1,
+    left: 1
+  };
+  function d3_svg_axisX(selection, x0, x1) {
+    selection.attr("transform", function(d) {
+      var v0 = x0(d);
+      return "translate(" + (isFinite(v0) ? v0 : x1(d)) + ",0)";
+    });
+  }
+  function d3_svg_axisY(selection, y0, y1) {
+    selection.attr("transform", function(d) {
+      var v0 = y0(d);
+      return "translate(0," + (isFinite(v0) ? v0 : y1(d)) + ")";
+    });
+  }
+  d3.svg.brush = function() {
+    var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0];
+    function brush(g) {
+      g.each(function() {
+        var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart);
+        var background = g.selectAll(".background").data([ 0 ]);
+        background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair");
+        g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move");
+        var resize = g.selectAll(".resize").data(resizes, d3_identity);
+        resize.exit().remove();
+        resize.enter().append("g").attr("class", function(d) {
+          return "resize " + d;
+        }).style("cursor", function(d) {
+          return d3_svg_brushCursor[d];
+        }).append("rect").attr("x", function(d) {
+          return /[ew]$/.test(d) ? -3 : null;
+        }).attr("y", function(d) {
+          return /^[ns]/.test(d) ? -3 : null;
+        }).attr("width", 6).attr("height", 6).style("visibility", "hidden");
+        resize.style("display", brush.empty() ? "none" : null);
+        var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range;
+        if (x) {
+          range = d3_scaleRange(x);
+          backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]);
+          redrawX(gUpdate);
+        }
+        if (y) {
+          range = d3_scaleRange(y);
+          backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]);
+          redrawY(gUpdate);
+        }
+        redraw(gUpdate);
+      });
+    }
+    brush.event = function(g) {
+      g.each(function() {
+        var event_ = event.of(this, arguments), extent1 = {
+          x: xExtent,
+          y: yExtent,
+          i: xExtentDomain,
+          j: yExtentDomain
+        }, extent0 = this.__chart__ || extent1;
+        this.__chart__ = extent1;
+        if (d3_transitionInheritId) {
+          d3.select(this).transition().each("start.brush", function() {
+            xExtentDomain = extent0.i;
+            yExtentDomain = extent0.j;
+            xExtent = extent0.x;
+            yExtent = extent0.y;
+            event_({
+              type: "brushstart"
+            });
+          }).tween("brush:brush", function() {
+            var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);
+            xExtentDomain = yExtentDomain = null;
+            return function(t) {
+              xExtent = extent1.x = xi(t);
+              yExtent = extent1.y = yi(t);
+              event_({
+                type: "brush",
+                mode: "resize"
+              });
+            };
+          }).each("end.brush", function() {
+            xExtentDomain = extent1.i;
+            yExtentDomain = extent1.j;
+            event_({
+              type: "brush",
+              mode: "resize"
+            });
+            event_({
+              type: "brushend"
+            });
+          });
+        } else {
+          event_({
+            type: "brushstart"
+          });
+          event_({
+            type: "brush",
+            mode: "resize"
+          });
+          event_({
+            type: "brushend"
+          });
+        }
+      });
+    };
+    function redraw(g) {
+      g.selectAll(".resize").attr("transform", function(d) {
+        return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")";
+      });
+    }
+    function redrawX(g) {
+      g.select(".extent").attr("x", xExtent[0]);
+      g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]);
+    }
+    function redrawY(g) {
+      g.select(".extent").attr("y", yExtent[0]);
+      g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]);
+    }
+    function brushstart() {
+      var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset;
+      var w = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup);
+      if (d3.event.changedTouches) {
+        w.on("touchmove.brush", brushmove).on("touchend.brush", brushend);
+      } else {
+        w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend);
+      }
+      g.interrupt().selectAll("*").interrupt();
+      if (dragging) {
+        origin[0] = xExtent[0] - origin[0];
+        origin[1] = yExtent[0] - origin[1];
+      } else if (resizing) {
+        var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing);
+        offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ];
+        origin[0] = xExtent[ex];
+        origin[1] = yExtent[ey];
+      } else if (d3.event.altKey) center = origin.slice();
+      g.style("pointer-events", "none").selectAll(".resize").style("display", null);
+      d3.select("body").style("cursor", eventTarget.style("cursor"));
+      event_({
+        type: "brushstart"
+      });
+      brushmove();
+      function keydown() {
+        if (d3.event.keyCode == 32) {
+          if (!dragging) {
+            center = null;
+            origin[0] -= xExtent[1];
+            origin[1] -= yExtent[1];
+            dragging = 2;
+          }
+          d3_eventPreventDefault();
+        }
+      }
+      function keyup() {
+        if (d3.event.keyCode == 32 && dragging == 2) {
+          origin[0] += xExtent[1];
+          origin[1] += yExtent[1];
+          dragging = 0;
+          d3_eventPreventDefault();
+        }
+      }
+      function brushmove() {
+        var point = d3.mouse(target), moved = false;
+        if (offset) {
+          point[0] += offset[0];
+          point[1] += offset[1];
+        }
+        if (!dragging) {
+          if (d3.event.altKey) {
+            if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ];
+            origin[0] = xExtent[+(point[0] < center[0])];
+            origin[1] = yExtent[+(point[1] < center[1])];
+          } else center = null;
+        }
+        if (resizingX && move1(point, x, 0)) {
+          redrawX(g);
+          moved = true;
+        }
+        if (resizingY && move1(point, y, 1)) {
+          redrawY(g);
+          moved = true;
+        }
+        if (moved) {
+          redraw(g);
+          event_({
+            type: "brush",
+            mode: dragging ? "move" : "resize"
+          });
+        }
+      }
+      function move1(point, scale, i) {
+        var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max;
+        if (dragging) {
+          r0 -= position;
+          r1 -= size + position;
+        }
+        min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i];
+        if (dragging) {
+          max = (min += position) + size;
+        } else {
+          if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min));
+          if (position < min) {
+            max = min;
+            min = position;
+          } else {
+            max = position;
+          }
+        }
+        if (extent[0] != min || extent[1] != max) {
+          if (i) yExtentDomain = null; else xExtentDomain = null;
+          extent[0] = min;
+          extent[1] = max;
+          return true;
+        }
+      }
+      function brushend() {
+        brushmove();
+        g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null);
+        d3.select("body").style("cursor", null);
+        w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null);
+        dragRestore();
+        event_({
+          type: "brushend"
+        });
+      }
+    }
+    brush.x = function(z) {
+      if (!arguments.length) return x;
+      x = z;
+      resizes = d3_svg_brushResizes[!x << 1 | !y];
+      return brush;
+    };
+    brush.y = function(z) {
+      if (!arguments.length) return y;
+      y = z;
+      resizes = d3_svg_brushResizes[!x << 1 | !y];
+      return brush;
+    };
+    brush.clamp = function(z) {
+      if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null;
+      if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z;
+      return brush;
+    };
+    brush.extent = function(z) {
+      var x0, x1, y0, y1, t;
+      if (!arguments.length) {
+        if (x) {
+          if (xExtentDomain) {
+            x0 = xExtentDomain[0], x1 = xExtentDomain[1];
+          } else {
+            x0 = xExtent[0], x1 = xExtent[1];
+            if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1);
+            if (x1 < x0) t = x0, x0 = x1, x1 = t;
+          }
+        }
+        if (y) {
+          if (yExtentDomain) {
+            y0 = yExtentDomain[0], y1 = yExtentDomain[1];
+          } else {
+            y0 = yExtent[0], y1 = yExtent[1];
+            if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1);
+            if (y1 < y0) t = y0, y0 = y1, y1 = t;
+          }
+        }
+        return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ];
+      }
+      if (x) {
+        x0 = z[0], x1 = z[1];
+        if (y) x0 = x0[0], x1 = x1[0];
+        xExtentDomain = [ x0, x1 ];
+        if (x.invert) x0 = x(x0), x1 = x(x1);
+        if (x1 < x0) t = x0, x0 = x1, x1 = t;
+        if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ];
+      }
+      if (y) {
+        y0 = z[0], y1 = z[1];
+        if (x) y0 = y0[1], y1 = y1[1];
+        yExtentDomain = [ y0, y1 ];
+        if (y.invert) y0 = y(y0), y1 = y(y1);
+        if (y1 < y0) t = y0, y0 = y1, y1 = t;
+        if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ];
+      }
+      return brush;
+    };
+    brush.clear = function() {
+      if (!brush.empty()) {
+        xExtent = [ 0, 0 ], yExtent = [ 0, 0 ];
+        xExtentDomain = yExtentDomain = null;
+      }
+      return brush;
+    };
+    brush.empty = function() {
+      return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1];
+    };
+    return d3.rebind(brush, event, "on");
+  };
+  var d3_svg_brushCursor = {
+    n: "ns-resize",
+    e: "ew-resize",
+    s: "ns-resize",
+    w: "ew-resize",
+    nw: "nwse-resize",
+    ne: "nesw-resize",
+    se: "nwse-resize",
+    sw: "nesw-resize"
+  };
+  var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ];
+  var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat;
+  var d3_time_formatUtc = d3_time_format.utc;
+  var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ");
+  d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso;
+  function d3_time_formatIsoNative(date) {
+    return date.toISOString();
+  }
+  d3_time_formatIsoNative.parse = function(string) {
+    var date = new Date(string);
+    return isNaN(date) ? null : date;
+  };
+  d3_time_formatIsoNative.toString = d3_time_formatIso.toString;
+  d3_time.second = d3_time_interval(function(date) {
+    return new d3_date(Math.floor(date / 1e3) * 1e3);
+  }, function(date, offset) {
+    date.setTime(date.getTime() + Math.floor(offset) * 1e3);
+  }, function(date) {
+    return date.getSeconds();
+  });
+  d3_time.seconds = d3_time.second.range;
+  d3_time.seconds.utc = d3_time.second.utc.range;
+  d3_time.minute = d3_time_interval(function(date) {
+    return new d3_date(Math.floor(date / 6e4) * 6e4);
+  }, function(date, offset) {
+    date.setTime(date.getTime() + Math.floor(offset) * 6e4);
+  }, function(date) {
+    return date.getMinutes();
+  });
+  d3_time.minutes = d3_time.minute.range;
+  d3_time.minutes.utc = d3_time.minute.utc.range;
+  d3_time.hour = d3_time_interval(function(date) {
+    var timezone = date.getTimezoneOffset() / 60;
+    return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5);
+  }, function(date, offset) {
+    date.setTime(date.getTime() + Math.floor(offset) * 36e5);
+  }, function(date) {
+    return date.getHours();
+  });
+  d3_time.hours = d3_time.hour.range;
+  d3_time.hours.utc = d3_time.hour.utc.range;
+  d3_time.month = d3_time_interval(function(date) {
+    date = d3_time.day(date);
+    date.setDate(1);
+    return date;
+  }, function(date, offset) {
+    date.setMonth(date.getMonth() + offset);
+  }, function(date) {
+    return date.getMonth();
+  });
+  d3_time.months = d3_time.month.range;
+  d3_time.months.utc = d3_time.month.utc.range;
+  function d3_time_scale(linear, methods, format) {
+    function scale(x) {
+      return linear(x);
+    }
+    scale.invert = function(x) {
+      return d3_time_scaleDate(linear.invert(x));
+    };
+    scale.domain = function(x) {
+      if (!arguments.length) return linear.domain().map(d3_time_scaleDate);
+      linear.domain(x);
+      return scale;
+    };
+    function tickMethod(extent, count) {
+      var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target);
+      return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) {
+        return d / 31536e6;
+      }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i];
+    }
+    scale.nice = function(interval, skip) {
+      var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval);
+      if (method) interval = method[0], skip = method[1];
+      function skipped(date) {
+        return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length;
+      }
+      return scale.domain(d3_scale_nice(domain, skip > 1 ? {
+        floor: function(date) {
+          while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1);
+          return date;
+        },
+        ceil: function(date) {
+          while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1);
+          return date;
+        }
+      } : interval));
+    };
+    scale.ticks = function(interval, skip) {
+      var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ {
+        range: interval
+      }, skip ];
+      if (method) interval = method[0], skip = method[1];
+      return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip);
+    };
+    scale.tickFormat = function() {
+      return format;
+    };
+    scale.copy = function() {
+      return d3_time_scale(linear.copy(), methods, format);
+    };
+    return d3_scale_linearRebind(scale, linear);
+  }
+  function d3_time_scaleDate(t) {
+    return new Date(t);
+  }
+  var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ];
+  var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ];
+  var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) {
+    return d.getMilliseconds();
+  } ], [ ":%S", function(d) {
+    return d.getSeconds();
+  } ], [ "%I:%M", function(d) {
+    return d.getMinutes();
+  } ], [ "%I %p", function(d) {
+    return d.getHours();
+  } ], [ "%a %d", function(d) {
+    return d.getDay() && d.getDate() != 1;
+  } ], [ "%b %d", function(d) {
+    return d.getDate() != 1;
+  } ], [ "%B", function(d) {
+    return d.getMonth();
+  } ], [ "%Y", d3_true ] ]);
+  var d3_time_scaleMilliseconds = {
+    range: function(start, stop, step) {
+      return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate);
+    },
+    floor: d3_identity,
+    ceil: d3_identity
+  };
+  d3_time_scaleLocalMethods.year = d3_time.year;
+  d3_time.scale = function() {
+    return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat);
+  };
+  var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) {
+    return [ m[0].utc, m[1] ];
+  });
+  var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) {
+    return d.getUTCMilliseconds();
+  } ], [ ":%S", function(d) {
+    return d.getUTCSeconds();
+  } ], [ "%I:%M", function(d) {
+    return d.getUTCMinutes();
+  } ], [ "%I %p", function(d) {
+    return d.getUTCHours();
+  } ], [ "%a %d", function(d) {
+    return d.getUTCDay() && d.getUTCDate() != 1;
+  } ], [ "%b %d", function(d) {
+    return d.getUTCDate() != 1;
+  } ], [ "%B", function(d) {
+    return d.getUTCMonth();
+  } ], [ "%Y", d3_true ] ]);
+  d3_time_scaleUtcMethods.year = d3_time.year.utc;
+  d3_time.scale.utc = function() {
+    return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat);
+  };
+  d3.text = d3_xhrType(function(request) {
+    return request.responseText;
+  });
+  d3.json = function(url, callback) {
+    return d3_xhr(url, "application/json", d3_json, callback);
+  };
+  function d3_json(request) {
+    return JSON.parse(request.responseText);
+  }
+  d3.html = function(url, callback) {
+    return d3_xhr(url, "text/html", d3_html, callback);
+  };
+  function d3_html(request) {
+    var range = d3_document.createRange();
+    range.selectNode(d3_document.body);
+    return range.createContextualFragment(request.responseText);
+  }
+  d3.xml = d3_xhrType(function(request) {
+    return request.responseXML;
+  });
+  if (typeof define === "function" && define.amd) this.d3 = d3, define(d3); else if (typeof module === "object" && module.exports) module.exports = d3; else this.d3 = d3;
+}();
+},{}],26:[function(require,module,exports){
+
+// TODO commute literals on the left side of a target operand, when possible
+
+module.exports = solve;
+function solve(target, source) {
+    return solve.semantics.solve(target, source);
+}
+
+solve.semantics = {
+
+    solve: function (target, source) {
+        while (true) {
+            // simplify the target
+            while (this.simplifiers.hasOwnProperty(target.type)) {
+                var simplification = this.simplifiers[target.type](target);
+                if (simplification) {
+                    target = simplification;
+                } else {
+                    break;
+                }
+            }
+            var canRotateTargetToSource = this.rotateTargetToSource.hasOwnProperty(target.type);
+            var canRotateSourceToTarget = this.rotateSourceToTarget.hasOwnProperty(source.type);
+            // solve for bindable target (rotate terms to source)
+            if (!canRotateTargetToSource && !canRotateSourceToTarget) {
+                break;
+            } else if (canRotateTargetToSource) {
+                source = this.rotateTargetToSource[target.type](target, source);
+                target = target.args[0];
+            } else if (canRotateSourceToTarget) {
+                target = this.rotateSourceToTarget[source.type](target, source);
+                source = source.args[0];
+            }
+        }
+
+        return [target, source];
+    },
+
+    simplifiers: {
+        // !!x -> x
+        not: function (syntax) {
+            var left = syntax.args[0];
+            if (left.type === "not") {
+                return left.args[0];
+            }
+        },
+        // "" + x -> x.toString()
+        add: function (syntax) {
+            var left = syntax.args[0];
+            if (left.type === "literal" && left.value === "") {
+                // "" + x
+                // toString(x)
+                // because this can be bound bidirectionally with toNumber(y)
+                return {
+                    type: "toString",
+                    args: [syntax.args[1]]
+                };
+            }
+        },
+        // DeMorgan's law applied to `some` so we only have to implement
+        // `every`.
+        // some{x} -> !every{!x}
+        someBlock: function (syntax) {
+            return {type: "not", args: [
+                {type: "everyBlock", args: [
+                    syntax.args[0],
+                    {type: "not", args: [
+                        syntax.args[1]
+                    ]}
+                ]}
+            ]};
+        }
+    },
+
+    rotateTargetToSource: {
+        // e.g.,
+        // !y = x
+        // y = !x
+        reflect: function (target, source) {
+            return {type: target.type, args: [source]};
+        },
+        // e.g.,
+        // y + 1 = x
+        // y = x - 1
+        invert: function (target, source, operator) {
+            return {type: operator, args: [
+                source,
+                target.args[1]
+            ]};
+        },
+        toNumber: function (target, source) {
+            return this.reflect(target, source);
+        },
+        toString: function (target, source) {
+            return this.reflect(target, source);
+        },
+        not: function (target, source) {
+            return this.reflect(target, source);
+        },
+        neg: function (target, source) {
+            return this.reflect(target, source);
+        },
+        add: function (target, source) {
+            return this.invert(target, source, 'sub');
+        },
+        sub: function (target, source) {
+            return this.invert(target, source, 'add');
+        },
+        mul: function (target, source) {
+            return this.invert(target, source, 'div');
+        },
+        div: function (target, source) {
+            return this.invert(target, source, 'mul');
+        },
+        pow: function (target, source) {
+            return this.invert(target, source, 'root');
+        },
+        root: function (target, source) {
+            return this.invert(target, source, 'pow');
+        },
+        // terms.join(delimiter) <- string
+        // terms <- string.split(delimiter)
+        join: function (target, source) {
+            return this.invert(target, source, 'split');
+        },
+        split: function (target, source) {
+            return this.invert(target, source, 'join');
+        }
+    },
+
+    rotateSourceToTarget: {
+        // y = x.rangeContent()
+        // y.rangeContent() = x
+        rangeContent: function (target, source) {
+            if (target.type === "rangeContent") {
+                return target;
+            } else {
+                return {type: source.type, args: [target]};
+            }
+        }
+    }
+
+};
+
+
+},{}],27:[function(require,module,exports){
+
+var parse = require("./parse");
+var solve = require("./algebra");
+var stringify = require("./stringify");
+var compileObserver = require("./compile-observer");
+var compileBinder = require("./compile-binder");
+var compileAssigner = require("./compile-assigner");
+var Observers = require("./observers");
+var observeRangeChange = Observers.observeRangeChange;
+var Binders = require("./binders");
+var Scope = require("./scope");
+
+module.exports = bind;
+function bind(target, targetPath, descriptor) {
+
+    descriptor.target = target;
+    descriptor.targetPath = targetPath;
+    var source = descriptor.source = descriptor.source || target;
+
+    var sourcePath = descriptor["<-"] || descriptor["<->"] || "";
+    var twoWay = descriptor.twoWay = "<->" in descriptor;
+    descriptor.sourcePath = sourcePath;
+    var value = descriptor.value;
+    var parameters = descriptor.parameters = descriptor.parameters || source;
+    var document = descriptor.document;
+    var components = descriptor.components;
+    var trace = descriptor.trace;
+
+    // TODO: consider the possibility that source and target have intrinsic
+    // scope properties
+
+    var sourceScope = descriptor.sourceScope = new Scope(source);
+    sourceScope.parameters = parameters;
+    sourceScope.document = document;
+    sourceScope.components = components;
+    var targetScope = descriptor.targetScope = new Scope(target);
+    targetScope.parameters = parameters;
+    targetScope.document = document;
+    targetScope.components = components;
+
+    // promote convert and revert from a converter object up to the descriptor
+    if (descriptor.converter) {
+        var converter = descriptor.converter;
+        if (converter.convert) {
+            descriptor.convert = converter.convert.bind(converter);
+        }
+        if (converter.revert) {
+            descriptor.revert = converter.revert.bind(converter);
+        }
+    } else if (descriptor.reverter) {
+        var reverter = descriptor.reverter;
+        if (reverter.convert) {
+            descriptor.revert = reverter.convert.bind(reverter);
+        }
+        if (reverter.revert) {
+            descriptor.convert = reverter.revert.bind(reverter);
+        }
+    }
+
+    var convert = descriptor.convert;
+    var revert = descriptor.revert;
+
+    var sourceSyntax = descriptor.sourceSyntax = parse(sourcePath);
+    var targetSyntax = descriptor.targetSyntax = parse(targetPath);
+
+    var solution = solve(targetSyntax, sourceSyntax);
+    targetSyntax = solution[0];
+    sourceSyntax = solution[1];
+
+    if (twoWay) {
+        if (targetSyntax.type === "rangeContent") {
+            return bindRangeContent(
+                targetScope,
+                targetSyntax.args[0],
+                sourceScope,
+                sourceSyntax,
+                convert,
+                revert,
+                descriptor,
+                trace ? {
+                    sourcePath: stringify(sourceSyntax),
+                    targetPath: stringify(targetSyntax.args[0])
+                } : null
+            );
+        }
+    }
+
+    // <- source to target
+    trace && console.log("DEFINE BINDING", targetPath, "<-", sourcePath, target);
+    var cancelSourceToTarget = bindOneWay(
+        targetScope,
+        targetSyntax,
+        sourceScope,
+        sourceSyntax,
+        convert,
+        descriptor,
+        trace
+    );
+
+    // flip the arrow
+    var solution = solve(sourceSyntax, targetSyntax);
+    sourceSyntax = solution[0];
+    targetSyntax = solution[1];
+
+    // -> target to source
+    var cancelTargetToSource = Function.noop;
+    if (twoWay) {
+        trace && console.log("DEFINE BINDING", targetPath, "->", sourcePath, source);
+        cancelTargetToSource = bindOneWay(
+            sourceScope,
+            sourceSyntax,
+            targetScope,
+            targetSyntax,
+            revert,
+            descriptor,
+            trace
+        );
+    }
+
+    return function cancel() {
+        cancelSourceToTarget();
+        cancelTargetToSource();
+    };
+
+}
+
+function bindOneWay(
+    targetScope,
+    targetSyntax,
+    sourceScope,
+    sourceSyntax,
+    convert,
+    descriptor,
+    trace
+) {
+
+    var observeSource = compileObserver(sourceSyntax);
+    if (convert) {
+        observeSource = Observers.makeConverterObserver(
+            observeSource,
+            convert,
+            sourceScope
+        );
+    }
+
+    var bindTarget = compileBinder(targetSyntax);
+    return bindTarget(
+        observeSource,
+        sourceScope,
+        targetScope,
+        descriptor,
+        trace ? {
+            sourcePath: stringify(sourceSyntax),
+            targetPath: stringify(targetSyntax)
+        } : null
+    );
+
+}
+
+function bindRangeContent(
+    targetScope,
+    targetSyntax,
+    sourceScope,
+    sourceSyntax,
+    convert,
+    revert,
+    descriptor,
+    trace
+) {
+
+    var observeSource = compileObserver(sourceSyntax);
+    var observeTarget = compileObserver(targetSyntax);
+    var assignSource = compileAssigner(sourceSyntax);
+    var assignTarget = compileAssigner(targetSyntax);
+
+    var cancel = Function.noop;
+
+    var target;
+    var source;
+    // We make multiple uses of the isActive variable.
+    var isActive;
+
+    // We will observe the source and target expressions independently. For
+    // initialization, if both produce an array, the source will overwrite the
+    // content of the target.  If only the source produces an array, we will
+    // propagate it to the target, and if only the target produces an array,
+    // we'll propagate it to the source. If neither produces an array, we will
+    // assign one.
+
+    // We check the target expression first, but we will use isActive to
+    // prevent the target from overwriting an existing source.
+
+    isActive = true;
+    var cancelTargetObserver = observeTarget(function replaceRangeContentTarget(_target) {
+        cancel();
+        cancel = Function.noop;
+        trace && console.log("RANGE CONTENT TARGET", trace.targetPath, "SET TO", _target);
+        if (_target && _target.addRangeChangeListener) {
+            target = _target;
+            if (source && target) {
+                trace && console.log("RANGE CONTENT TARGET REPLACES SOURCE", trace.targetPath, "->", trace.sourcePath, "WITH", target);
+                isActive = true;
+                source.swap(0, source.length, target);
+                isActive = false;
+                cancel = establishRangeContentBinding();
+            } else if (!source && !isActive) {
+                trace && console.log("RANGE CONTENT TARGET INITIALIZED TO COPY OF SOURCE", trace.targetPath, "<-", tarce.sourcePath, "WITH", source);
+                assignSource(target.clone(), sourceScope);
+            }
+        }
+    }, targetScope);
+    isActive = false;
+
+    var cancelSourceObserver = observeSource(function replaceRangeContentSource(_source) {
+        cancel();
+        cancel = Function.noop;
+        trace && console.log("RANGE CONTENT SOURCE", trace.sourcePath, "SET TO", _source);
+        if (_source && _source.addRangeChangeListener) {
+            source = _source;
+            if (target && source) {
+                trace && console.log("RANGE CONTENT SOURCE REPLACES TARGET", trace.targetPath, "<-", trace.sourcePath, "WITH", source);
+                isActive = true;
+                target.swap(0, target.length, source);
+                isActive = false;
+                cancel = establishRangeContentBinding();
+            } else if (!target) {
+                assignTarget(source.clone(), targetScope);
+            }
+        }
+    }, sourceScope);
+
+    // Even if neither the source nor target are provided, we will kick off
+    // with an empty array. The source will propagate to the target.
+    if (!target && !source) {
+        assignSource([], sourceScope);
+    }
+
+    function sourceRangeChange(plus, minus, index) {
+        if (!isActive) {
+            isActive = true;
+            trace && console.log("RANGE CONTENT PROPAGATED", trace.targetPath, "<-", trace.sourcePath, "PLUS", plus, "MINUS", minus, "AT", index);
+            target.swap(index, minus.length, plus);
+            isActive = false;
+        }
+    }
+
+    function targetRangeChange(plus, minus, index) {
+        if (!isActive) {
+            isActive = true;
+            trace && console.log("RANGE CONTENT PROPAGATED", trace.targetPath, "->", trace.sourcePath, "PLUS", plus, "MINUS", minus, "AT", index);
+            source.swap(index, minus.length, plus);
+            isActive = false;
+        }
+    }
+
+    function establishRangeContentBinding() {
+        if (source === target) {
+            return;
+        }
+        trace && console.log("RANGE CONTENT BOUND", trace.targetPath, "<->", trace.sourcePath);
+        isActive = true;
+        var cancelSourceRangeChangeObserver = observeRangeChange(source, sourceRangeChange, sourceScope);
+        var cancelTargetRangeChangeObserver = observeRangeChange(target, targetRangeChange, targetScope);
+        isActive = false;
+        return function cancelRangeContentBinding() {
+            trace && console.log("RANGE CONTENT UNBOUND", trace.targetPath, "<->", trace.sourcePath);
+            cancelSourceRangeChangeObserver();
+            cancelTargetRangeChangeObserver();
+        };
+    }
+
+    return function cancelRangeContentBinding() {
+        cancel();
+        cancelTargetObserver();
+        cancelSourceObserver();
+    };
+}
+
+
+},{"./algebra":26,"./binders":28,"./compile-assigner":30,"./compile-binder":31,"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66,"./stringify":67}],28:[function(require,module,exports){
+
+var Scope = require("./scope");
+var Observers = require("./observers");
+var observeRangeChange = Observers.observeRangeChange;
+var cancelEach = Observers.cancelEach;
+var makeNotObserver = Observers.makeNotObserver;
+var makeOrObserver = Observers.makeOrObserver;
+var makeAndObserver = Observers.makeAndObserver;
+var observeValue = Observers.observeValue;
+var observeUndefined = Observers.makeLiteralObserver();
+var trueScope = new Scope(true);
+var falseScope = new Scope(false);
+
+function getStackTrace() {
+    return new Error("").stack.replace(/^.*\n.*\n/, "\n");
+}
+
+exports.bindProperty = bindProperty;
+var _bindProperty = bindProperty; // to bypass scope shadowing problems below
+function bindProperty(object, key, observeValue, source, descriptor, trace) {
+    return observeValue(function replaceBoundPropertyValue(value) {
+        if (descriptor.isActive) {
+            return;
+        }
+        try {
+            descriptor.isActive = true;
+            trace && console.log("SET", trace.targetPath, "TO", value, "ON", object, "BECAUSE", trace.sourcePath, getStackTrace());
+            if (Array.isArray(object) && key >>> 0 === key) {
+                // TODO spec this case
+                object.set(key, value);
+            } else {
+                object[key] = value;
+            }
+        } finally {
+            descriptor.isActive = false;
+        }
+    }, source);
+}
+
+exports.makePropertyBinder = makePropertyBinder;
+function makePropertyBinder(observeObject, observeKey) {
+    return function bindProperty(observeValue, source, target, descriptor, trace) {
+        return observeKey(function replaceKey(key) {
+            if (key == null) return;
+            return observeObject(function replaceObject(object) {
+                if (object == null) return;
+                if (object.bindProperty) {
+                    return object.bindProperty(key, observeValue, source, descriptor, trace);
+                } else {
+                    return _bindProperty(object, key, observeValue, source, descriptor, trace);
+                }
+            }, target);
+        }, target);
+    };
+}
+
+exports.bindGet = bindGet;
+var _bindGet = bindGet; // to bypass scope shadowing below
+function bindGet(collection, key, observeValue, source, descriptor, trace) {
+    return observeValue(function replaceValue(value) {
+        if (descriptor.isActive) {
+            return;
+        }
+        try {
+            descriptor.isActive = true;
+            trace && console.log("SET FOR KEY", key, "TO", value, "ON", collection, "BECAUSE", trace.sourcePath, getStackTrace());
+            collection.set(key, value);
+        } finally {
+            descriptor.isActive = false;
+        }
+    }, source);
+}
+
+exports.makeGetBinder = makeGetBinder;
+function makeGetBinder(observeCollection, observeKey) {
+    return function bindGet(observeValue, source, target, descriptor, trace) {
+        return observeCollection(function replaceCollection(collection) {
+            if (!collection) return;
+            return observeKey(function replaceKey(key) {
+                if (key == null) return;
+                return _bindGet(collection, key, observeValue, source, descriptor, trace);
+            }, target);
+        }, target);
+    };
+}
+
+exports.makeHasBinder = makeHasBinder;
+function makeHasBinder(observeSet, observeValue) {
+    return function bindHas(observeHas, source, target, descriptor, trace) {
+        return observeSet(function replaceHasBindingSet(set) {
+            if (!set) return;
+            return observeValue(function replaceHasBindingValue(value) {
+                if (value == null) return;
+                return observeHas(function changeWhetherSetHas(has) {
+                    // wait for the initial value to be updated by the
+                    // other-way binding
+                    if (has) { // should be in set
+                        if (!(set.has || set.contains).call(set, value)) {
+                            trace && console.log("ADD", value, "TO", trace.targetPath, "BECAUSE", trace.sourcePath, getStackTrace());
+                            set.add(value);
+                        }
+                    } else { // should not be in set
+                        while ((set.has || set.contains).call(set, value)) {
+                            trace && console.log("REMOVE", value, "FROM", trace.targetPath, "BECAUSE", trace.sourcePath, getStackTrace());
+                            (set.remove || set['delete']).call(set, value);
+                        }
+                    }
+                }, source);
+            }, target);
+        }, target);
+    };
+}
+
+// a == b <-> c
+exports.makeEqualityBinder = makeEqualityBinder;
+function makeEqualityBinder(bindLeft, observeRight) {
+    return function bindEquals(observeEquals, source, target, descriptor, trace) {
+        // c
+        return observeEquals(function changeWhetherEquals(equals) {
+            if (equals) {
+                trace && console.log("BIND", trace.targetPath, "TO", trace.sourcePath, getStackTrace());
+                // a <-> b
+                var cancel = bindLeft(observeRight, source, source, descriptor, trace) || Function.noop;
+                return function cancelEqualityBinding() {
+                    cancel();
+                    trace && console.log("UNBIND", trace.targetPath, "FROM", trace.sourcePath, getStackTrace());
+                };
+            }
+        }, target);
+    };
+}
+
+// collection.every{condition} <- everyCondition
+exports.makeEveryBlockBinder = makeEveryBlockBinder;
+function makeEveryBlockBinder(observeCollection, bindCondition, observeValue) {
+    return function bindEveryBlock(observeEveryCondition, source, target, descriptor, trace) {
+        return observeEveryCondition(function replaceCondition(condition) {
+            if (!condition) return;
+            return observeCollection(function replaceCollection(collection) {
+                if (!collection) return;
+                var cancelers = [];
+                function rangeChange(plus, minus, index) {
+                    cancelers.swap(index, minus.length, plus.map(function (value, offset) {
+                        var scope = target.nest(value);
+                        return bindCondition(observeValue, scope, scope, descriptor, trace);
+                    }));
+                }
+                var cancelRangeChange = observeRangeChange(collection, rangeChange, target) || Function.noop;
+                return function cancelEveryBinding() {
+                    cancelEach(cancelers);
+                    cancelRangeChange();
+                };
+            }, target);
+        }, source);
+    };
+};
+
+exports.makeAndBinder = makeAndBinder;
+function makeAndBinder(bindLeft, bindRight, observeLeft, observeRight, observeLeftBind, observeRightBind) {
+    var observeNotRight = makeNotObserver(observeRight);
+    var observeLeftAndNotRight = makeAndObserver(observeLeft, observeNotRight);
+    return function bindEveryBlock(observeAndCondition, source, target, descriptor, trace) {
+        return observeAndCondition(function replaceAndCondition(condition) {
+            if (condition == null) {
+            } else if (condition) {
+                var cancelLeft = bindLeft(observeLeftBind, trueScope, target, descriptor, trace) || Function.noop;
+                var cancelRight = bindRight(observeRightBind, trueScope, target, descriptor, trace) || Function.noop;
+                return function cancelAndBinding() {
+                    cancelLeft();
+                    cancelRight();
+                };
+            } else {
+                return bindLeft(observeLeftAndNotRight, target, target, descriptor, trace);
+            }
+        }, source);
+    };
+}
+
+exports.makeOrBinder = makeOrBinder;
+function makeOrBinder(bindLeft, bindRight, observeLeft, observeRight, observeLeftBind, observeRightBind) {
+    var observeNotRight = makeNotObserver(observeRight);
+    var observeLeftOrNotRight = makeOrObserver(observeLeft, observeNotRight);
+    return function bindEveryBlock(observeOrCondition, source, target, descriptor, trace) {
+        return observeOrCondition(function replaceOrCondition(condition) {
+            if (condition == null) {
+            } else if (!condition) {
+                var cancelLeft = bindLeft(observeLeftBind, falseScope, target, descriptor, trace) || Function.noop;
+                var cancelRight = bindRight(observeRightBind, falseScope, target, descriptor, trace) || Function.noop;
+                return function cancelOrBinding() {
+                    cancelLeft();
+                    cancelRight();
+                };
+            } else {
+                return bindLeft(observeLeftOrNotRight, target, target, descriptor, trace);
+            }
+        }, source);
+    };
+}
+
+// (a ? b : c) <- d
+exports.makeConditionalBinder = makeConditionalBinder;
+function makeConditionalBinder(observeCondition, bindConsequent, bindAlternate) {
+    return function bindCondition(observeSource, source, target, descriptor, trace) {
+        // a
+        return observeCondition(function replaceCondition(condition) {
+            if (condition == null) return;
+            if (condition) {
+                // b <- d
+                return bindConsequent(observeSource, source, target, descriptor, trace);
+            } else {
+                // c <- d
+                return bindAlternate(observeSource, source, target, descriptor, trace);
+            }
+        }, source);
+    };
+}
+
+// collection.only() <- value
+exports.makeOnlyBinder = makeOnlyBinder;
+function makeOnlyBinder(observeCollection) {
+    return function bindOnly(observeValue, sourceScope, targetScope, descriptor, trace) {
+        return observeCollection(function replaceCollection(collection) {
+            if (!collection) return;
+            return observeValue(function replaceOnlyValue(value) {
+                if (value == null) return;
+                if (collection.splice) {
+                    collection.splice(0, collection.length, value);
+                } else if (collection.clear && collection.add) {
+                    collection.clear();
+                    collection.add(value);
+                }
+            }, sourceScope);
+        }, targetScope);
+    };
+}
+
+// collection.one() <- value
+// empty the collection and set its one item to value
+exports.makeOneBinder = makeOneBinder;
+function makeOneBinder(observeCollection) {
+    return function bindOne(observeValue, sourceScope, targetScope, descriptor, trace) {
+        return observeCollection(function replaceCollection(collection) {
+            if (!collection) return;
+            return observeValue(function replaceOneValue(value) {
+                if (value == null) return;
+
+                // FIXME: this is debatable. If set to its current value, do we clear the rest of the collection?
+                // I err towards no, in part because this solves the case of two-way bindings, where we were always
+                // clearing out the source collection. That could be solved other ways without this little quirk.
+                if (value === collection.one()) return;
+
+                if (collection.splice) {
+                    collection.splice(0, collection.length, value);
+                } else if (collection.clear && collection.add) {
+                    collection.clear();
+                    collection.add(value);
+                }
+            }, sourceScope);
+        }, targetScope);
+    };
+}
+
+// a.rangeContent() <- b
+exports.makeRangeContentBinder = makeRangeContentBinder;
+function makeRangeContentBinder(observeTarget, bindTarget) {
+    return function bindRangeContent(observeSource, sourceScope, targetScope, descriptor, trace) {
+        return observeTarget(function replaceRangeContentTarget(target) {
+            if (!target) {
+                return bindTarget(
+                    Observers.makeLiteralObserver([]),
+                    sourceScope,
+                    targetScope,
+                    descriptor,
+                    trace
+                );
+            }
+
+            return observeSource(function replaceRangeContentSource(source) {
+                if (source === target) {
+                    return;
+                }
+                if (!source) {
+                    target.clear();
+                    return;
+                }
+                if (!source.addRangeChangeListener) {
+                    return;
+                }
+
+                function rangeContentSourceRangeChange(plus, minus, index) {
+                    if (isActive(target))
+                        return;
+                    if (trace) {
+                        console.log("SWAPPING", minus, "FOR", plus, "AT", index, "ON", trace.targetPath, getStackTrace());
+                    }
+                    if (target.swap) {
+                        target.swap(index, minus.length, plus);
+                    } else if (target.add && (target.remove || target["delete"])) {
+                        plus.forEach(target.add, target);
+                        minus.forEach(target.remove || target["delete"], target);
+                    }
+                }
+
+                source.addRangeChangeListener(rangeContentSourceRangeChange);
+                rangeContentSourceRangeChange(Array.from(source), Array.from(target), 0);
+                return function cancelRangeContentBinding() {
+                    source.removeRangeChangeListener(rangeContentSourceRangeChange);
+                };
+            }, sourceScope);
+        }, targetScope);
+    };
+}
+
+exports.makeMapContentBinder = makeMapContentBinder;
+function makeMapContentBinder(observeTarget) {
+    return function bindMapContent(observeSource, source, target, descriptor, trace) {
+        return observeTarget(function replaceMapContentBindingTarget(target) {
+            if (!target) return;
+            return observeSource(function replaceMapContentBindingSource(source) {
+                if (!source) {
+                    target.clear();
+                    return;
+                }
+
+                function mapChange(value, key) {
+                    if (descriptor.isActive) {
+                        return;
+                    }
+                    try {
+                        descriptor.isActive = true;
+                        if (value === undefined) {
+                            if (trace) {
+                                trace && console.log("DELETED", trace.targetPath, "FOR KEY", key, "ON", target, "BECAUSE", trace.sourcePath, getStackTrace());
+                            }
+                            if (Array.isArray(target)) {
+                                target.splice(key, 1);
+                            } else {
+                                target["delete"](key);
+                            }
+                        } else {
+                            if (trace) {
+                                trace && console.log("SET", trace.targetPath, "FOR KEY", key, "TO", value, "ON", target, "BECAUSE", trace.sourcePath, getStackTrace());
+                            }
+                            target.set(key, value);
+                        }
+                    } finally {
+                        descriptor.isActive = false;
+                    }
+                }
+                target.clear();
+                source.forEach(mapChange);
+                return source.addMapChangeListener(mapChange);
+            }, source);
+        }, target);
+    };
+}
+
+// a.reversed() <-> b
+exports.makeReversedBinder = makeReversedBinder;
+function makeReversedBinder(observeTarget) {
+    return function bindReversed(observeSource, source, target, descriptor, trace) {
+        return observeTarget(function replaceReversedBindingTarget(target) {
+            if (!target) return;
+            return observeSource(function replaceReversedBindingSource(source) {
+                if (!source) {
+                    target.clear();
+                    return;
+                }
+
+                function rangeChange(plus, minus, index) {
+                    if (isActive(target))
+                        return;
+                    var reflected = target.length - index - minus.length;
+                    target.swap(reflected, minus.length, plus.reversed());
+                }
+                source.addRangeChangeListener(rangeChange);
+                rangeChange(source, target, 0);
+                return function cancelReversedBinding() {
+                    source.removeRangeChangeListener(rangeChange);
+                };
+            }, source);
+        }, target);
+    };
+}
+
+exports.makeDefinedBinder = makeDefinedBinder;
+function makeDefinedBinder(bindTarget) {
+    return function bindReversed(observeSource, sourceScope, targetScope, descriptor, trace) {
+        return observeSource(function replaceSource(condition) {
+            if (!condition) {
+                return bindTarget(
+                    observeUndefined,
+                    sourceScope,
+                    targetScope,
+                    descriptor,
+                    trace
+                );
+            }
+        }, targetScope);
+    }
+}
+
+exports.makeParentBinder = makeParentBinder;
+function makeParentBinder(bindTarget) {
+    return function bindParent(observeSource, sourceScope, targetScope, descriptor, trace) {
+        if (!targetScope.parent) {
+            return;
+        }
+        return bindTarget(observeSource, sourceScope, targetScope.parent, descriptor, trace);
+    };
+}
+
+exports.makeWithBinder = makeWithBinder;
+function makeWithBinder(observeTarget, bindTarget) {
+    return function bindWith(observeSource, sourceScope, targetScope, descriptor, trace) {
+        return observeTarget(function replaceTarget(target) {
+            if (target == null) {
+                return;
+            }
+            return bindTarget(
+                observeSource,
+                sourceScope,
+                targetScope.nest(target),
+                descriptor,
+                trace
+            );
+        }, targetScope);
+    };
+}
+
+function isActive(target) {
+    return (
+        target.getRangeChangeDescriptor &&
+        target.getRangeChangeDescriptor().isActive
+    );
+}
+
+
+},{"./observers":63,"./scope":66}],29:[function(require,module,exports){
+
+var Map = require("collections/map");
+var bind = require("./bind");
+var compute = require("./compute");
+var observe = require("./observe");
+var stringify = require("./stringify");
+
+var bindingsForObject = new Map();
+var owns = Object.prototype.hasOwnProperty;
+
+exports.count = 0;
+exports.bindings = bindingsForObject;
+
+exports.defineBindings = defineBindings;
+function defineBindings(object, descriptors, commonDescriptor) {
+    if (descriptors) {
+        for (var name in descriptors) {
+            defineBinding(object, name, descriptors[name], commonDescriptor);
+        }
+    }
+    return object;
+}
+
+exports.defineBinding = defineBinding;
+function defineBinding(object, name, descriptor, commonDescriptor) {
+    commonDescriptor = commonDescriptor || Object.empty;
+    var bindingsForName = getBindings(object);
+    if (owns.call(bindingsForName, name)) {
+        throw new Error("Can't bind to already bound target, " + JSON.stringify(name));
+    }
+    if ("<-" in descriptor || "<->" in descriptor || "compute" in descriptor) {
+        descriptor.target = object;
+        descriptor.parameters = descriptor.parameters || commonDescriptor.parameters;
+        descriptor.document = descriptor.document || commonDescriptor.document;
+        descriptor.components = descriptor.components || commonDescriptor.components;
+        if ("compute" in descriptor) {
+            descriptor.cancel = compute(object, name, descriptor);
+        } else {
+            descriptor.cancel = bind(object, name, descriptor);
+        }
+        bindingsForName[name] = descriptor;
+        exports.count++;
+    } else {
+        if (!("get" in descriptor) && !("set" in descriptor) && !("writable" in descriptor)) {
+            descriptor.writable = true;
+        }
+        if (!("configurable" in descriptor)) {
+            descriptor.configurable = true;
+        }
+        if (!("enumerable" in descriptor)) {
+            descriptor.enumerable = true;
+        }
+        Object.defineProperty(object, name, descriptor);
+    }
+    return object;
+}
+
+exports.getBindings = getBindings;
+function getBindings(object) {
+    if (!bindingsForObject.has(object)) {
+        bindingsForObject.set(object, {});
+    }
+    return bindingsForObject.get(object);
+}
+
+exports.getBinding = getBinding;
+function getBinding(object, name) {
+    var bindingsForName = getBindings(object);
+    return bindingsForName[name];
+}
+
+exports.cancelBindings = cancelBindings;
+function cancelBindings(object) {
+    var bindings = getBindings(object);
+    for (var name in bindings) {
+        cancelBinding(object, name);
+    }
+}
+
+exports.cancelBinding = cancelBinding;
+function cancelBinding(object, name) {
+    var bindings = getBindings(object);
+    if (!bindings[name]) {
+        throw new Error("Can't cancel non-existent binding to " + JSON.stringify(name));
+    }
+    var binding = bindings[name];
+    if (binding && binding.cancel) {
+        binding.cancel();
+        delete bindings[name];
+        exports.count--;
+        for (var name in bindings) {
+            return; // if there are any remaining bindings, short-circuit
+        }
+        bindingsForObject["delete"](object);
+    }
+}
+
+
+},{"./bind":27,"./compute":34,"./observe":62,"./stringify":67,"collections/map":51}],30:[function(require,module,exports){
+
+var compileEvaluator = require("./compile-evaluator");
+var solve = require("./algebra");
+var Scope = require("./scope");
+var valueSyntax = {type: "value"};
+var trueScope = {type: "literal", value: true};
+var falseScope = {type: "literal", value: false};
+
+module.exports = compile;
+function compile(syntax) {
+    return compile.semantics.compile(syntax);
+}
+
+compile.semantics = {
+
+    compile: function (syntax) {
+        var compilers = this.compilers;
+        if (syntax.type === "equals") {
+            var assignLeft = this.compile(syntax.args[0]);
+            var evaluateRight = this.compileEvaluator(syntax.args[1]);
+            return compilers.equals(assignLeft, evaluateRight);
+        } else if (syntax.type === "if") {
+            var evaluateCondition = this.compileEvaluator(syntax.args[0]);
+            var assignConsequent = this.compile(syntax.args[1]);
+            var assignAlternate = this.compile(syntax.args[2]);
+            return compilers["if"](evaluateCondition, assignConsequent, assignAlternate);
+        } else if (syntax.type === "and" || syntax.type === "or") {
+            var leftArgs = solve(syntax.args[0], valueSyntax);
+            var rightArgs = solve(syntax.args[1], valueSyntax);
+            var evaluateLeft = this.compileEvaluator(syntax.args[0]);
+            var evaluateRight = this.compileEvaluator(syntax.args[1]);
+            var evaluateLeftAssign = this.compileEvaluator(leftArgs[1]);
+            var evaluateRightAssign = this.compileEvaluator(rightArgs[1]);
+            var assignLeft = this.compile(leftArgs[0]);
+            var assignRight = this.compile(rightArgs[0]);
+            return compilers[syntax.type](
+                assignLeft,
+                assignRight,
+                evaluateLeft,
+                evaluateRight,
+                evaluateLeftAssign,
+                evaluateRightAssign
+            );
+        } else if (syntax.type === "everyBlock") {
+            var evaluateCollection = this.compileEvaluator(syntax.args[0]);
+            var args = solve(syntax.args[1], {type: "literal", value: true});
+            var assignCondition = this.compile(args[0]);
+            var evaluateValue = this.compileEvaluator(args[1]);
+            return compilers["everyBlock"](evaluateCollection, assignCondition, evaluateValue);
+        } else if (syntax.type === "parent") {
+            var assignParent = this.compile(syntax.args[0]);
+            return function (value, scope) {
+                return assignParent(value, scope.parent);
+            };
+        } else if (compilers.hasOwnProperty(syntax.type)) {
+            var argEvaluators = syntax.args.map(this.compileEvaluator, this.compileEvaluator.semantics);
+            return compilers[syntax.type].apply(null, argEvaluators);
+        } else {
+            throw new Error("Can't compile assigner for " + JSON.stringify(syntax.type));
+        }
+    },
+
+    compileEvaluator: compileEvaluator,
+
+    compilers: {
+
+        property: function (evaluateObject, evaluateKey) {
+            return function (value, scope) {
+                var object = evaluateObject(scope);
+                if (!object) return;
+                var key = evaluateKey(scope);
+                if (key == null) return;
+                if (Array.isArray(object)) {
+                    object.set(key, value);
+                } else {
+                    object[key] = value;
+                }
+            };
+        },
+
+        get: function (evaluateCollection, evaluateKey) {
+            return function (value, scope) {
+                var collection = evaluateCollection(scope);
+                if (!collection) return;
+                var key = evaluateKey(scope);
+                if (key == null) return;
+                collection.set(key, value);
+            };
+        },
+
+        has: function (evaluateCollection, evaluateValue) {
+            return function (has, scope) {
+                var collection = evaluateCollection(scope);
+                if (!collection) return;
+                var value = evaluateValue(scope);
+                if (has == null) return;
+                if (has) {
+                    if (!(collection.has || collection.contains).call(collection, value)) {
+                        collection.add(value);
+                    }
+                } else {
+                    if ((collection.has || collection.contains).call(collection, value)) {
+                        (collection.remove || collection["delete"]).call(collection, value);
+                    }
+                }
+            };
+        },
+
+        equals: function (assignLeft, evaluateRight) {
+            return function (value, scope) {
+                if (value) {
+                    return assignLeft(evaluateRight(scope), scope);
+                }
+            };
+        },
+
+        "if": function (evaluateCondition, assignConsequent, assignAlternate) {
+            return function (value, scope) {
+                var condition = evaluateCondition(scope);
+                if (condition == null) return;
+                if (condition) {
+                    return assignConsequent(value, scope);
+                } else {
+                    return assignAlternate(value, scope);
+                }
+            };
+        },
+
+        and: function (assignLeft, assignRight, evaluateLeft, evaluateRight, evaluateLeftAssign, evaluateRightAssign) {
+            return function (value, scope) {
+                if (value == null) return;
+                if (value) {
+                    assignLeft(evaluateLeftAssign(trueScope), scope);
+                    assignRight(evaluateRightAssign(trueScope), scope);
+                } else {
+                    assignLeft(evaluateLeft(scope) && !evaluateRight(scope), scope);
+                }
+            }
+        },
+
+        or: function (assignLeft, assignRight, evaluateLeft, evaluateRight, evaluateLeftAssign, evaluateRightAssign) {
+            return function (value, scope) {
+                if (value == null) return;
+                if (!value) {
+                    assignLeft(evaluateLeftAssign(falseScope), scope);
+                    assignRight(evaluateRightAssign(falseScope), scope);
+                } else {
+                    assignLeft(evaluateLeft(scope) || !evaluateRight(scope), scope);
+                }
+            }
+        },
+
+        rangeContent: function (evaluateTarget) {
+            return function (value, scope) {
+                var target = evaluateTarget(scope);
+                if (!target) return;
+                if (!value) {
+                    target.clear();
+                } else {
+                    target.swap(0, target.length, value);
+                }
+            };
+        },
+
+        mapContent: function (evaluateTarget) {
+            return function (value, scope) {
+                var target = evaluateTarget(scope);
+                if (!target) return;
+                target.clear();
+                if (scope.value) {
+                    target.addEach(value);
+                }
+            };
+        },
+
+        reversed: function (evaluateTarget) {
+            return function (value, scope) {
+                var target = evaluateTarget(scope);
+                if (!target) return;
+                target.swap(0, target.length, value.reversed());
+            };
+        },
+
+        everyBlock: function (evaluateCollection, assignCondition, evaluateEffect) {
+            return function (value, scope) {
+                if (value) {
+                    var collection = evaluateCollection(scope);
+                    var effect = evaluateEffect(scope);
+                    collection.forEach(function (content) {
+                        assignCondition(effect, scope.nest(content));
+                    });
+                }
+            };
+        }
+
+    }
+
+}
+
+
+},{"./algebra":26,"./compile-evaluator":32,"./scope":66}],31:[function(require,module,exports){
+
+var compileObserver = require("./compile-observer");
+var Observers = require("./observers");
+var Binders = require("./binders");
+var solve = require("./algebra");
+
+var valueSyntax = {type: "value"};
+var trueSyntax = {type: "literal", value: true};
+
+module.exports = compile;
+function compile(syntax) {
+    return compile.semantics.compile(syntax);
+}
+
+compile.semantics = {
+
+    compilers: {
+        property: Binders.makePropertyBinder,
+        get: Binders.makeGetBinder,
+        has: Binders.makeHasBinder,
+        only: Binders.makeOnlyBinder,
+        one: Binders.makeOneBinder,
+        rangeContent: Binders.makeRangeContentBinder,
+        mapContent: Binders.makeMapContentBinder,
+        reversed: Binders.makeReversedBinder,
+        and: Binders.makeAndBinder,
+        or: Binders.makeOrBinder
+    },
+
+    compile: function (syntax) {
+        var compilers = this.compilers;
+        if (syntax.type === "default") {
+            return this.compile(syntax.args[0]);
+        } else if (syntax.type === "literal") {
+            if (syntax.value == null) {
+                return Function.noop;
+            } else {
+                throw new Error("Can't bind to literal: " + syntax.value);
+            }
+        } else if (syntax.type === "equals") {
+            var bindLeft = this.compile(syntax.args[0]);
+            var observeRight = compileObserver(syntax.args[1]);
+            return Binders.makeEqualityBinder(bindLeft, observeRight);
+        } else if (syntax.type === "if") {
+            var observeCondition = compileObserver(syntax.args[0]);
+            var bindConsequent = this.compile(syntax.args[1]);
+            var bindAlternate = this.compile(syntax.args[2]);
+            return Binders.makeConditionalBinder(observeCondition, bindConsequent, bindAlternate);
+        } else if (syntax.type === "and" || syntax.type === "or") {
+            var leftArgs = solve(syntax.args[0], valueSyntax);
+            var rightArgs = solve(syntax.args[1], valueSyntax);
+            var bindLeft = this.compile(leftArgs[0]);
+            var bindRight = this.compile(rightArgs[0]);
+            var observeLeftBind = compileObserver(leftArgs[1]);
+            var observeRightBind = compileObserver(rightArgs[1]);
+            var observeLeft = compileObserver(syntax.args[0]);
+            var observeRight = compileObserver(syntax.args[1]);
+            return this.compilers[syntax.type](
+                bindLeft,
+                bindRight,
+                observeLeft,
+                observeRight,
+                observeLeftBind,
+                observeRightBind
+            );
+        } else if (syntax.type === "everyBlock") {
+            var observeCollection = compileObserver(syntax.args[0]);
+            var args = solve(syntax.args[1], trueSyntax);
+            var bindCondition = this.compile(args[0]);
+            var observeValue = compileObserver(args[1]);
+            return Binders.makeEveryBlockBinder(observeCollection, bindCondition, observeValue);
+        } else if (syntax.type === "rangeContent") {
+            var observeTarget = compileObserver(syntax.args[0]);
+            var bindTarget;
+            try {
+                bindTarget = this.compile(syntax.args[0]);
+            } catch (exception) {
+                bindTarget = Function.noop;
+            }
+            return Binders.makeRangeContentBinder(observeTarget, bindTarget);
+        } else if (syntax.type === "defined") {
+            var bindTarget = this.compile(syntax.args[0]);
+            return Binders.makeDefinedBinder(bindTarget);
+        } else if (syntax.type === "parent") {
+            var bindTarget = this.compile(syntax.args[0]);
+            return Binders.makeParentBinder(bindTarget);
+        } else if (syntax.type === "with") {
+            var observeTarget = compileObserver(syntax.args[0]);
+            var bindTarget = this.compile(syntax.args[1]);
+            return Binders.makeWithBinder(observeTarget, bindTarget);
+        } else if (compilers.hasOwnProperty(syntax.type)) {
+            var argObservers = syntax.args.map(compileObserver, compileObserver.semantics);
+            return compilers[syntax.type].apply(null, argObservers);
+        } else {
+            throw new Error("Can't compile binder for " + JSON.stringify(syntax.type));
+        }
+    }
+
+};
+
+
+},{"./algebra":26,"./binders":28,"./compile-observer":33,"./observers":63}],32:[function(require,module,exports){
+
+var Object = require("collections/shim-object");
+var Map = require("collections/map");
+var SortedSet = require("collections/sorted-set");
+var Operators = require("./operators");
+var Scope = require("./scope");
+
+module.exports = compile;
+function compile(syntax) {
+    return compile.semantics.compile(syntax);
+}
+
+var compilers = {
+
+    literal: function (syntax) {
+        return function () {
+            return syntax.value;
+        };
+    },
+
+    value: function (syntax) {
+        return function (scope) {
+            return scope.value;
+        };
+    },
+
+    parameters: function (syntax) {
+        return function (scope) {
+            return scope.parameters;
+        };
+    },
+
+    element: function (syntax) {
+        return function (scope) {
+            return scope.document.getElementById(syntax.id);
+        };
+    },
+
+    component: function (syntax) {
+        return function (scope) {
+            return scope.components.getObjectByLabel(syntax.label);
+        };
+    },
+
+    tuple: function (syntax) {
+        var argEvaluators = syntax.args.map(this.compile, this);
+        return function (scope) {
+            return argEvaluators.map(function (evaluateArg) {
+                return evaluateArg(scope);
+            });
+        };
+    },
+
+    record: function (syntax) {
+        var args = syntax.args;
+        var argEvaluators = {};
+        for (var name in args) {
+            argEvaluators[name] = this.compile(args[name]);
+        }
+        return function (scope) {
+            var object = {};
+            for (var name in argEvaluators) {
+                object[name] = argEvaluators[name](scope);
+            }
+            return object;
+        };
+    }
+
+};
+
+var argCompilers = {
+
+    mapBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .map(function (value) {
+                return evaluateRelation(scope.nest(value));
+            });
+        };
+    },
+
+    filterBlock: function (evaluateCollection, evaluatePredicate) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .filter(function (value) {
+                return evaluatePredicate(scope.nest(value));
+            });
+        };
+    },
+
+    someBlock: function (evaluateCollection, evaluatePredicate) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .some(function (value) {
+                return evaluatePredicate(scope.nest(value));
+            });
+        };
+    },
+
+    everyBlock: function (evaluateCollection, evaluatePredicate) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .every(function (value) {
+                return evaluatePredicate(scope.nest(value));
+            });
+        };
+    },
+
+    sortedBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .sorted(Function.by(function (value) {
+                return evaluateRelation(scope.nest(value));
+            }));
+        };
+    },
+
+    sortedSetBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            function map(x) {
+                return evaluateRelation(scope.nest(x));
+            }
+            function contentCompare(x, y) {
+                return Object.compare(map(x), map(y));
+            }
+            function contentEquals(x, y) {
+                return Object.equals(map(x), map(y));
+            }
+            return new SortedSet(
+                evaluateCollection(scope),
+                contentEquals,
+                contentCompare
+            );
+        };
+    },
+
+    groupBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .group(function (value) {
+                return evaluateRelation(scope.nest(value));
+            });
+        };
+    },
+
+    groupMapBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return new Map(evaluateCollection(scope)
+            .group(function (value) {
+                return evaluateRelation(scope.nest(value));
+            }));
+        };
+    },
+
+    minBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .min(Function.by(function (value) {
+                return evaluateRelation(scope.nest(value));
+            }))
+        };
+    },
+
+    maxBlock: function (evaluateCollection, evaluateRelation) {
+        return function (scope) {
+            return evaluateCollection(scope)
+            .max(Function.by(function (value) {
+                return evaluateRelation(scope.nest(value));
+            }))
+        };
+    },
+
+    parent: function (evaluateExpression) {
+        return function (scope) {
+            return evaluateExpression(scope.parent);
+        };
+    },
+
+    "with": function (evaluateContext, evaluateExpression) {
+        return function (scope) {
+            return evaluateExpression(scope.nest(evaluateContext(scope)));
+        };
+    },
+
+    "if": function (evaluateCondition, evaluateConsequent, evaluateAlternate) {
+        return function (scope) {
+            var condition = evaluateCondition(scope);
+            if (condition == null) return;
+            if (condition) {
+                return evaluateConsequent(scope);
+            } else {
+                return evaluateAlternate(scope);
+            }
+        }
+    },
+
+    not: function (evaluateValue) {
+        return function (scope) {
+            return !evaluateValue(scope);
+        };
+    },
+
+    and: function (evaluateLeft, evaluateRight) {
+        return function (scope) {
+            return evaluateLeft(scope) && evaluateRight(scope);
+        };
+    },
+
+    or: function (evaluateLeft, evaluateRight) {
+        return function (scope) {
+            return evaluateLeft(scope) || evaluateRight(scope);
+        };
+    },
+
+    "default": function (evaluateLeft, evaluateRight) {
+        return function (scope) {
+            var result = evaluateLeft(scope);
+            if (result == null) { // implies "iff === null or undefined"
+                result = evaluateRight(scope);
+            }
+            return result;
+        }
+    },
+
+    defined: function (evaluate) {
+        return function (scope) {
+            var value = evaluate(scope);
+            return value != null; // implies exactly !== null or undefined
+        };
+    },
+
+    // TODO rename to evaluate
+    path: function (evaluateObject, evaluatePath) {
+        return function (scope) {
+            var value = evaluateObject(scope);
+            var path = evaluatePath(scope);
+            var parse = require("./parse");
+            try {
+                var syntax = parse(path);
+                var evaluate = compile(syntax);
+                return evaluate(scope.nest(value));
+            } catch (exception) {
+            }
+        }
+    }
+
+};
+
+var operators = Object.clone(Operators, 1);
+
+Object.addEach(operators, {
+
+    property: function (object, key) {
+        return object[key];
+    },
+
+    get: function (collection, key) {
+        return collection.get(key);
+    },
+
+    mapContent: Function.identity,
+
+    rangeContent: Function.identity,
+
+    view: function (collection, start, length) {
+        return collection.slice(start, start + length);
+    }
+
+});
+
+var semantics = compile.semantics = {
+
+    compilers: compilers,
+    argCompilers: argCompilers,
+    operators: operators,
+
+    compile: function (syntax) {
+        var compilers = this.compilers;
+        var argCompilers = this.argCompilers;
+        var operators = this.operators;
+        if (compilers.hasOwnProperty(syntax.type)) {
+            return compilers[syntax.type].call(this, syntax);
+        } else if (argCompilers.hasOwnProperty(syntax.type)) {
+            var argEvaluators = syntax.args.map(this.compile, this);
+            return argCompilers[syntax.type].apply(null, argEvaluators);
+        } else {
+            if (!operators.hasOwnProperty(syntax.type)) {
+                operators[syntax.type] = function (object) {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    if (!object[syntax.type])
+                        throw new TypeError("Can't call " + JSON.stringify(syntax.type) + " of " + object);
+                    return object[syntax.type].apply(object, args);
+                };
+            }
+            var operator = operators[syntax.type];
+            var argEvaluators = syntax.args.map(this.compile, this);
+            return function (scope) {
+                var args = argEvaluators.map(function (evaluateArg) {
+                    return evaluateArg(scope);
+                });
+                if (!args.every(Operators.defined))
+                    return;
+                return operator.apply(null, args);
+            };
+        }
+
+    }
+
+};
+
+
+},{"./operators":64,"./parse":65,"./scope":66,"collections/map":51,"collections/shim-object":56,"collections/sorted-set":60}],33:[function(require,module,exports){
+
+var Observers = require("./observers");
+var Operators = require("./operators");
+
+module.exports = compile;
+function compile(syntax) {
+    return semantics.compile(syntax);
+}
+
+var semantics = compile.semantics = {
+
+    compilers: {
+        property: Observers.makePropertyObserver,
+        get: Observers.makeGetObserver,
+        path: Observers.makePathObserver,
+        "with": Observers.makeWithObserver,
+        "if": Observers.makeConditionalObserver,
+        parent: Observers.makeParentObserver,
+        not: Observers.makeNotObserver,
+        and: Observers.makeAndObserver,
+        or: Observers.makeOrObserver,
+        "default": Observers.makeDefaultObserver,
+        defined: Observers.makeDefinedObserver,
+        rangeContent: Function.identity,
+        mapContent: Function.identity,
+        keys: Observers.makeKeysObserver,
+        values: Observers.makeValuesObserver,
+        items: Observers.makeEntriesObserver, // XXX deprecated
+        entries: Observers.makeEntriesObserver,
+        toMap: Observers.makeToMapObserver,
+        mapBlock: Observers.makeMapBlockObserver,
+        filterBlock: Observers.makeFilterBlockObserver,
+        everyBlock: Observers.makeEveryBlockObserver,
+        someBlock: Observers.makeSomeBlockObserver,
+        sortedBlock: Observers.makeSortedBlockObserver,
+        sortedSetBlock: Observers.makeSortedSetBlockObserver,
+        groupBlock: Observers.makeGroupBlockObserver,
+        groupMapBlock: Observers.makeGroupMapBlockObserver,
+        minBlock: Observers.makeMinBlockObserver,
+        maxBlock: Observers.makeMaxBlockObserver,
+        min: Observers.makeMinObserver,
+        max: Observers.makeMaxObserver,
+        enumerate: Observers.makeEnumerationObserver,
+        reversed: Observers.makeReversedObserver,
+        flatten: Observers.makeFlattenObserver,
+        concat: Observers.makeConcatObserver,
+        view: Observers.makeViewObserver,
+        sum: Observers.makeSumObserver,
+        average: Observers.makeAverageObserver,
+        last: Observers.makeLastObserver,
+        only: Observers.makeOnlyObserver,
+        one: Observers.makeOneObserver,
+        has: Observers.makeHasObserver,
+        // TODO zip
+        tuple: Observers.makeArrayObserver,
+        range: Observers.makeRangeObserver,
+        startsWith: Observers.makeStartsWithObserver,
+        endsWith: Observers.makeEndsWithObserver,
+        contains: Observers.makeContainsObserver,
+        join: Observers.makeJoinObserver,
+        toArray: Observers.makeToArrayObserver,
+        asArray: Observers.makeToArrayObserver // XXX deprecated
+    },
+
+    compile: function (syntax) {
+        var compilers = this.compilers;
+        if (syntax.type === "literal") {
+            return Observers.makeLiteralObserver(syntax.value);
+        } else if (syntax.type === "value") {
+            return Observers.observeValue;
+        } else if (syntax.type === "parameters") {
+            return Observers.observeParameters;
+        } else if (syntax.type === "element") {
+            return Observers.makeElementObserver(syntax.id);
+        } else if (syntax.type === "component") {
+            return Observers.makeComponentObserver(syntax.label, syntax);
+        } else if (syntax.type === "record") {
+            var observers = {};
+            var args = syntax.args;
+            for (var name in args) {
+                observers[name] = this.compile(args[name]);
+            }
+            return Observers.makeObjectObserver(observers);
+        } else {
+            if (!compilers.hasOwnProperty(syntax.type)) {
+                compilers[syntax.type] = Observers.makeMethodObserverMaker(syntax.type);
+            }
+            var argObservers = syntax.args.map(this.compile, this);
+            return compilers[syntax.type].apply(null, argObservers);
+        }
+    }
+
+};
+
+var compilers = semantics.compilers;
+Object.keys(Operators).forEach(function (name) {
+    if (!compilers[name]) {
+        compilers[name] = Observers.makeOperatorObserverMaker(Operators[name]);
+    }
+});
+
+// a special Hell for non-enumerable inheritance
+compilers.toString = Observers.makeOperatorObserverMaker(Operators.toString);
+
+
+},{"./observers":63,"./operators":64}],34:[function(require,module,exports){
+
+var parse = require("./parse");
+var compileObserver = require("./compile-observer");
+var compileBinder = require("./compile-binder");
+var Observers = require("./observers");
+var Scope = require("./scope");
+
+module.exports = compute;
+function compute(target, targetPath, descriptor) {
+    descriptor.target = target;
+    descriptor.targetPath = targetPath;
+    var source = descriptor.source = descriptor.source || target;
+    var args = descriptor.args;
+    var compute = descriptor.compute;
+    var parameters = descriptor.parameters = descriptor.parameters || source;
+    var document = descriptor.document;
+    var components = descriptor.components;
+    var trace = descriptor.trace;
+
+    // TODO consider the possibility that source and target have intrinsic
+    // scope properties
+    //
+    var sourceScope = descriptor.sourceScope = new Scope(source);
+    sourceScope.parameters = parameters;
+    sourceScope.document = document;
+    sourceScope.components = components;
+    var targetScope = descriptor.targetScope = new Scope(target);
+    targetScope.parameters = parameters;
+    targetScope.document = document;
+    targetScope.components = components;
+
+    var argObservers = args.map(function (arg) {
+        return parse(arg);
+    }).map(function (argSyntax) {
+        if (argSyntax.type === "rangeContent") {
+            var observeArg = compileObserver(argSyntax.args[0]);
+            return Observers.makeRangeContentObserver(observeArg);
+        } else if (argSyntax.type === "mapContent") {
+            var observeArg = compileObserver(argSyntax.args[0]);
+            return Observers.makeMapContentObserver(observeArg);
+        } else {
+            return compileObserver(argSyntax);
+        }
+    });
+    var argsObserver = Observers.makeRangeContentObserver(
+        Observers.makeObserversObserver(argObservers)
+    );
+    var observeSource = Observers.makeComputerObserver(argsObserver, compute, target);
+
+    var targetSyntax = parse(targetPath);
+    var bindTarget = compileBinder(targetSyntax);
+
+    return bindTarget(observeSource, sourceScope, targetScope, descriptor, trace ? {
+        sourcePath: args.join(", "),
+        targetPath: targetPath
+    }: undefined);
+}
+
+
+},{"./compile-binder":31,"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66}],35:[function(require,module,exports){
+
+var PropertyChanges = require("collections/listen/property-changes");
+
+// for whatever reason, HTMLInputElement is not the same as the global of the
+// same name, at least in Chrome
+
+function changeChecked(event) {
+    PropertyChanges.dispatchOwnPropertyChange(event.target, "checked", event.target.checked);
+}
+
+function changeValue(event) {
+    PropertyChanges.dispatchOwnPropertyChange(event.target, "value", event.target.value);
+}
+
+function changeInnerHTML(event) {
+    PropertyChanges.dispatchOwnPropertyChange(event.target, "innerHTML", event.target.innerHTML);
+    PropertyChanges.dispatchOwnPropertyChange(event.target, "innerText", event.target.innerText);
+    PropertyChanges.dispatchOwnPropertyChange(event.target, "value", event.target.innerText);
+}
+
+function makeObservable(key) {
+    if (key === "checked") {
+        this.addEventListener("change", changeChecked);
+    } else if (key === "value") {
+        this.addEventListener("change", changeValue);
+        if (this.type === "text" || this.nodeName === "TEXTAREA") {
+            this.addEventListener("keyup", changeValue);
+        } else if (this.contentEditable) {
+            this.innerText = this.innerText ? this.innerText : this.value;
+            this.addEventListener("keyup", changeInnerHTML);
+        }
+    }
+}
+
+function makeUnobservable(key) {
+    if (key === "checked") {
+        this.removeEventListener("change", changeChecked);
+    } else if (key === "value") {
+        this.removeEventListener("change", changeValue);
+        if (this.type === "text" || this.nodeName === "TEXTAREA") {
+            this.removeEventListener("keyup", changeValue);
+        } else if (this.contentEditable) {
+            this.removeEventListener("keyup", changeInnerHTML);
+        }
+    }
+}
+
+var HTMLInputElement = Object.getPrototypeOf(document.createElement("input"));
+HTMLInputElement.makePropertyObservable = makeObservable;
+HTMLInputElement.makePropertyUnobservable = makeUnobservable;
+
+var HTMLTextAreaElement = Object.getPrototypeOf(document.createElement("textarea"));
+HTMLTextAreaElement.makePropertyObservable = makeObservable;
+HTMLTextAreaElement.makePropertyUnobservable = makeUnobservable;
+
+var HTMLSpanElement = Object.getPrototypeOf(document.createElement("span"));
+HTMLSpanElement.makePropertyObservable = makeObservable;
+HTMLSpanElement.makePropertyUnobservable = makeUnobservable;
+
+// TODO make window.history state observable
+
+
+},{"collections/listen/property-changes":49}],36:[function(require,module,exports){
+module.exports = (function() {
+  /*
+   * Generated by PEG.js 0.7.0.
+   *
+   * http://pegjs.majda.cz/
+   */
+
+  function peg$subclass(child, parent) {
+    function ctor() { this.constructor = child; }
+    ctor.prototype = parent.prototype;
+    child.prototype = new ctor();
+  }
+
+  function SyntaxError(expected, found, offset, line, column) {
+    function buildMessage(expected, found) {
+      function stringEscape(s) {
+        function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }
+
+        return s
+          .replace(/\\/g,   '\\\\')
+          .replace(/"/g,    '\\"')
+          .replace(/\x08/g, '\\b')
+          .replace(/\t/g,   '\\t')
+          .replace(/\n/g,   '\\n')
+          .replace(/\f/g,   '\\f')
+          .replace(/\r/g,   '\\r')
+          .replace(/[\x00-\x07\x0B\x0E\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
+          .replace(/[\x10-\x1F\x80-\xFF]/g,    function(ch) { return '\\x'  + hex(ch); })
+          .replace(/[\u0180-\u0FFF]/g,         function(ch) { return '\\u0' + hex(ch); })
+          .replace(/[\u1080-\uFFFF]/g,         function(ch) { return '\\u'  + hex(ch); });
+      }
+
+      var expectedDesc, foundDesc;
+
+      switch (expected.length) {
+        case 0:
+          expectedDesc = "end of input";
+          break;
+
+        case 1:
+          expectedDesc = expected[0];
+          break;
+
+        default:
+          expectedDesc = expected.slice(0, -1).join(", ")
+            + " or "
+            + expected[expected.length - 1];
+      }
+
+      foundDesc = found ? "\"" + stringEscape(found) + "\"" : "end of input";
+
+      return "Expected " + expectedDesc + " but " + foundDesc + " found.";
+    }
+
+    this.expected = expected;
+    this.found    = found;
+    this.offset   = offset;
+    this.line     = line;
+    this.column   = column;
+
+    this.name     = "SyntaxError";
+    this.message  = buildMessage(expected, found);
+  }
+
+  peg$subclass(SyntaxError, Error);
+
+  function parse(input) {
+    var options = arguments.length > 1 ? arguments[1] : {},
+
+        peg$startRuleFunctions = { expression: peg$parseexpression, sheet: peg$parsesheet },
+        peg$startRuleFunction  = peg$parseexpression,
+
+        peg$c0 = "expression",
+        peg$c1 = null,
+        peg$c2 = [],
+        peg$c3 = ",",
+        peg$c4 = "\",\"",
+        peg$c5 = function(head, tail) {
+                var result = [head];
+                for (var i = 0; i < tail.length; i++) {
+                    result.push(tail[i][2]);
+                }
+                return result;
+            },
+        peg$c6 = "(",
+        peg$c7 = "\"(\"",
+        peg$c8 = ")",
+        peg$c9 = "\")\"",
+        peg$c10 = function() {
+                return [];
+            },
+        peg$c11 = function(expressions) {
+                return expressions;
+            },
+        peg$c12 = "",
+        peg$c13 = "?",
+        peg$c14 = "\"?\"",
+        peg$c15 = ":",
+        peg$c16 = "\":\"",
+        peg$c17 = function(condition, tail) {
+                if (tail) {
+                    var consequent = tail[2];
+                    var alternate = tail[6];
+                    return {
+                        type: "if",
+                        args: [condition, consequent, alternate]
+                    };
+                } else {
+                    return condition;
+                }
+            },
+        peg$c18 = "||",
+        peg$c19 = "\"||\"",
+        peg$c20 = function(head, tail) {
+                for (var i = 0; i < tail.length; i++) {
+                    head = {
+                        type: BINARY[tail[i][1]],
+                        args: [
+                            head,
+                            tail[i][3]
+                        ]
+                    }
+                }
+                return head;
+            },
+        peg$c21 = "&&",
+        peg$c22 = "\"&&\"",
+        peg$c23 = "<=>",
+        peg$c24 = "\"<=>\"",
+        peg$c25 = "<=",
+        peg$c26 = "\"<=\"",
+        peg$c27 = ">=",
+        peg$c28 = "\">=\"",
+        peg$c29 = "<",
+        peg$c30 = "\"<\"",
+        peg$c31 = "-",
+        peg$c32 = "\"-\"",
+        peg$c33 = ">",
+        peg$c34 = "\">\"",
+        peg$c35 = "==",
+        peg$c36 = "\"==\"",
+        peg$c37 = "!=",
+        peg$c38 = "\"!=\"",
+        peg$c39 = function(left, tail) {
+                if (!tail) {
+                    return left;
+                } else {
+                    var operator = tail[1];
+                    var right = tail[3];
+                    if (operator === "!=") {
+                        return {type: "not", args: [{type: "equals", args: [left, right]}]};
+                    } else {
+                        return {type: BINARY[operator], args: [left, right]};
+                    }
+                }
+            },
+        peg$c40 = "+",
+        peg$c41 = "\"+\"",
+        peg$c42 = "*",
+        peg$c43 = "\"*\"",
+        peg$c44 = "/",
+        peg$c45 = "\"/\"",
+        peg$c46 = "%",
+        peg$c47 = "\"%\"",
+        peg$c48 = "rem",
+        peg$c49 = "\"rem\"",
+        peg$c50 = "**",
+        peg$c51 = "\"**\"",
+        peg$c52 = "//",
+        peg$c53 = "\"//\"",
+        peg$c54 = "%%",
+        peg$c55 = "\"%%\"",
+        peg$c56 = "??",
+        peg$c57 = "\"??\"",
+        peg$c58 = "!",
+        peg$c59 = "\"!\"",
+        peg$c60 = function(operator, arg) {
+                return {type: UNARY[operator], args: [arg]};
+            },
+        peg$c61 = function(head, tail) {
+                for (var i = 0; i < tail.length; i++) {
+                    head = tail[i](head);
+                }
+                return head;
+            },
+        peg$c62 = ".",
+        peg$c63 = "\".\"",
+        peg$c64 = function(tail) {
+                return tail;
+            },
+        peg$c65 = "[",
+        peg$c66 = "\"[\"",
+        peg$c67 = "]",
+        peg$c68 = "\"]\"",
+        peg$c69 = function(arg) {
+                return function (previous) {
+                    return {
+                        type: "property",
+                        args: [
+                            previous,
+                            arg
+                        ]
+                    };
+                };
+            },
+        peg$c70 = "{",
+        peg$c71 = "\"{\"",
+        peg$c72 = "}",
+        peg$c73 = "\"}\"",
+        peg$c74 = function(name, expression) {
+                if (BLOCKS[name]) {
+                    return function (previous) {
+                        return {
+                            type: BLOCKS[name],
+                            args: [previous, expression]
+                        };
+                    }
+                } else if (expression.type === "value") {
+                    return function (previous) {
+                        return {
+                            type: name,
+                            args: [previous]
+                        };
+                    };
+                } else {
+                    return function (previous) {
+                        return {
+                            type: name,
+                            args: [
+                                {type: "mapBlock", args: [
+                                    previous,
+                                    expression
+                                ]}
+                            ]
+                        };
+                    };
+                }
+            },
+        peg$c75 = function(name, args) {
+                return function (previous) {
+                    return {
+                        type: name,
+                        args: [previous].concat(args)
+                    };
+                };
+            },
+        peg$c76 = function(index) {
+                return function (previous) {
+                    return {
+                        type: "property",
+                        args: [
+                            previous,
+                            {type: "literal", value: +index.join("")}
+                        ]
+                    };
+                };
+            },
+        peg$c77 = function(name) {
+                return function (previous) {
+                    return {
+                        type: "property",
+                        args: [
+                            previous,
+                            {type: "literal", value: name}
+                        ]
+                    };
+                };
+            },
+        peg$c78 = function(expression) {
+                return function (previous) {
+                    return {
+                        type: "with",
+                        args: [
+                            previous,
+                            expression
+                        ]
+                    };
+                };
+            },
+        peg$c79 = "this",
+        peg$c80 = "\"this\"",
+        peg$c81 = function() { return {type: "value"}; },
+        peg$c82 = "true",
+        peg$c83 = "\"true\"",
+        peg$c84 = function() { return {type: "literal", value: true}; },
+        peg$c85 = "false",
+        peg$c86 = "\"false\"",
+        peg$c87 = function() { return {type: "literal", value: false}; },
+        peg$c88 = "null",
+        peg$c89 = "\"null\"",
+        peg$c90 = function() { return {type: "literal", value: null}; },
+        peg$c91 = "@",
+        peg$c92 = "\"@\"",
+        peg$c93 = function(label) {
+                return {type: "component", label: label};
+            },
+        peg$c94 = "$",
+        peg$c95 = "\"$\"",
+        peg$c96 = function(name) {
+                return {type: "property", args: [
+                    {type: "parameters"},
+                    {type: "literal", value: name}
+                ]};
+            },
+        peg$c97 = function() {
+                return {type: "parameters"};
+            },
+        peg$c98 = "#",
+        peg$c99 = "\"#\"",
+        peg$c100 = function(name) {
+                return {type: "element", id: name};
+            },
+        peg$c101 = "&",
+        peg$c102 = "\"&\"",
+        peg$c103 = function(name, args) {
+                return {type: name, args: args, inline: true};
+            },
+        peg$c104 = "^",
+        peg$c105 = "\"^\"",
+        peg$c106 = function(value) {
+                return {type: "parent", args: [value]};
+            },
+        peg$c107 = function(expression) {
+                return expression;
+            },
+        peg$c108 = function(tail) {
+                return tail({type: "value"});
+            },
+        peg$c109 = function() {
+                return {type: "value"};
+            },
+        peg$c110 = "word",
+        peg$c111 = /^[a-zA-Z_0-9\-]/,
+        peg$c112 = "[a-zA-Z_0-9\\-]",
+        peg$c113 = "string",
+        peg$c114 = "'",
+        peg$c115 = "\"'\"",
+        peg$c116 = function(chars) { return {type: "literal", value: chars.join("")}; },
+        peg$c117 = "\"",
+        peg$c118 = "\"\\\"\"",
+        peg$c119 = /^[^'\\\0-\x1F]/,
+        peg$c120 = "[^'\\\\\\0-\\x1F]",
+        peg$c121 = "\\'",
+        peg$c122 = "\"\\\\'\"",
+        peg$c123 = function() { return "'";  },
+        peg$c124 = /^[^"\\\0-\x1F]/,
+        peg$c125 = "[^\"\\\\\\0-\\x1F]",
+        peg$c126 = "\\\"",
+        peg$c127 = "\"\\\\\\\"\"",
+        peg$c128 = function() { return "\"";  },
+        peg$c129 = "\\\\",
+        peg$c130 = "\"\\\\\\\\\"",
+        peg$c131 = function() { return "\\"; },
+        peg$c132 = "\\/",
+        peg$c133 = "\"\\\\/\"",
+        peg$c134 = function() { return "/";  },
+        peg$c135 = "\\b",
+        peg$c136 = "\"\\\\b\"",
+        peg$c137 = function() { return "\b"; },
+        peg$c138 = "\\f",
+        peg$c139 = "\"\\\\f\"",
+        peg$c140 = function() { return "\f"; },
+        peg$c141 = "\\n",
+        peg$c142 = "\"\\\\n\"",
+        peg$c143 = function() { return "\n"; },
+        peg$c144 = "\\r",
+        peg$c145 = "\"\\\\r\"",
+        peg$c146 = function() { return "\r"; },
+        peg$c147 = "\\t",
+        peg$c148 = "\"\\\\t\"",
+        peg$c149 = function() { return "\t"; },
+        peg$c150 = "\\0",
+        peg$c151 = "\"\\\\0\"",
+        peg$c152 = function() { return "\0"; },
+        peg$c153 = "\\u",
+        peg$c154 = "\"\\\\u\"",
+        peg$c155 = function(digits) {
+                return String.fromCharCode(parseInt(digits, 16));
+            },
+        peg$c156 = /^[0-9a-fA-F]/,
+        peg$c157 = "[0-9a-fA-F]",
+        peg$c158 = function() {
+                return {type: "tuple", args: []};
+            },
+        peg$c159 = function(expressions) {
+                return {type: "tuple", args: expressions};
+            },
+        peg$c160 = function() { return {type: "record", args: []}; },
+        peg$c161 = function(pairs) { return {type: "record", args: pairs}; },
+        peg$c162 = function(head, tail) {
+                var result = {};
+                result[head[0]] = head[1];
+                for (var i = 0; i < tail.length; i++) {
+                    result[tail[i][2][0]] = tail[i][2][1];
+                }
+                return result;
+            },
+        peg$c163 = function(name, value) { return [name, value]; },
+        peg$c164 = "number",
+        peg$c165 = function(parts) {
+                return {type: "literal", value: +parts}
+            },
+        peg$c166 = /^[eE]/,
+        peg$c167 = "[eE]",
+        peg$c168 = /^[+\-]/,
+        peg$c169 = "[+\\-]",
+        peg$c170 = /^[0-9]/,
+        peg$c171 = "[0-9]",
+        peg$c172 = /^[1-9]/,
+        peg$c173 = "[1-9]",
+        peg$c174 = "whitespace",
+        peg$c175 = /^[\t\x0B\f \xA0\uFEFF]/,
+        peg$c176 = "[\\t\\x0B\\f \\xA0\\uFEFF]",
+        peg$c177 = /^[ \xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000]/,
+        peg$c178 = "[ \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000]",
+        peg$c179 = "line terminator",
+        peg$c180 = /^[\n\r\u2028\u2029]/,
+        peg$c181 = "[\\n\\r\\u2028\\u2029]",
+        peg$c182 = "/*",
+        peg$c183 = "\"/*\"",
+        peg$c184 = "*/",
+        peg$c185 = "\"*/\"",
+        peg$c186 = "any character",
+        peg$c187 = function(comment) {
+                return comment;
+            },
+        peg$c188 = function(blocks) {
+                return {type: "sheet", blocks: blocks};
+            },
+        peg$c189 = function(label, annotation, statements) {
+                return {
+                    type: "block",
+                    connection: annotation.connection,
+                    module: annotation.module,
+                    exports: annotation.exports,
+                    label: label,
+                    statements: statements
+                };
+            },
+        peg$c190 = function(connection, module, exports) {
+                return {
+                    connection: {"<": "prototype", ":": "object"}[connection],
+                    module: module && module.value,
+                    exports: exports !== "" ? exports[1] : undefined
+                };
+            },
+        peg$c191 = function() {
+                return {};
+            },
+        peg$c192 = /^[a-zA-Z_0-9]/,
+        peg$c193 = "[a-zA-Z_0-9]",
+        peg$c194 = ";",
+        peg$c195 = "\";\"",
+        peg$c196 = function(statement) {
+                return [statement];
+            },
+        peg$c197 = "on",
+        peg$c198 = "\"on\"",
+        peg$c199 = "before",
+        peg$c200 = "\"before\"",
+        peg$c201 = " ",
+        peg$c202 = "\" \"",
+        peg$c203 = "->",
+        peg$c204 = "\"->\"",
+        peg$c205 = function(when, type, listener) {
+                return {type: "event", when: when, event: type, listener: listener};
+            },
+        peg$c206 = "<->",
+        peg$c207 = "\"<->\"",
+        peg$c208 = "<-",
+        peg$c209 = "\"<-\"",
+        peg$c210 = function(target, arrow, source, descriptor) {
+                var result = {type: STATEMENTS[arrow], args: [
+                    target,
+                    source
+                ]};
+                if (descriptor.length) {
+                    var describe = {};
+                    for (var i = 0; i < descriptor.length; i++) {
+                        describe[descriptor[i][2]] = descriptor[i][6];
+                    }
+                    result.descriptor = describe;
+                }
+                return result;
+            },
+        peg$c211 = function(name, expression) {
+                return {type: "unit", name: name, value: expression};
+            },
+
+        peg$currPos          = 0,
+        peg$reportedPos      = 0,
+        peg$cachedPos        = 0,
+        peg$cachedPosDetails = { line: 1, column: 1, seenCR: false },
+        peg$maxFailPos       = 0,
+        peg$maxFailExpected  = [],
+        peg$silentFails      = 0,
+
+        peg$result;
+
+    if ("startRule" in options) {
+      if (!(options.startRule in peg$startRuleFunctions)) {
+        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+      }
+
+      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
+
+    function text() {
+      return input.substring(peg$reportedPos, peg$currPos);
+    }
+
+    function offset() {
+      return peg$reportedPos;
+    }
+
+    function line() {
+      return peg$computePosDetails(peg$reportedPos).line;
+    }
+
+    function column() {
+      return peg$computePosDetails(peg$reportedPos).column;
+    }
+
+    function peg$computePosDetails(pos) {
+      function advance(details, startPos, endPos) {
+        var p, ch;
+
+        for (p = startPos; p < endPos; p++) {
+          ch = input.charAt(p);
+          if (ch === "\n") {
+            if (!details.seenCR) { details.line++; }
+            details.column = 1;
+            details.seenCR = false;
+          } else if (ch === "\r" || ch === "\u2028" || ch === "\u2029") {
+            details.line++;
+            details.column = 1;
+            details.seenCR = true;
+          } else {
+            details.column++;
+            details.seenCR = false;
+          }
+        }
+      }
+
+      if (peg$cachedPos !== pos) {
+        if (peg$cachedPos > pos) {
+          peg$cachedPos = 0;
+          peg$cachedPosDetails = { line: 1, column: 1, seenCR: false };
+        }
+        advance(peg$cachedPosDetails, peg$cachedPos, pos);
+        peg$cachedPos = pos;
+      }
+
+      return peg$cachedPosDetails;
+    }
+
+    function peg$fail(expected) {
+      if (peg$currPos < peg$maxFailPos) { return; }
+
+      if (peg$currPos > peg$maxFailPos) {
+        peg$maxFailPos = peg$currPos;
+        peg$maxFailExpected = [];
+      }
+
+      peg$maxFailExpected.push(expected);
+    }
+
+    function peg$cleanupExpected(expected) {
+      var i = 0;
+
+      expected.sort();
+
+      while (i < expected.length) {
+        if (expected[i - 1] === expected[i]) {
+          expected.splice(i, 1);
+        } else {
+          i++;
+        }
+      }
+    }
+
+    function peg$parseexpression() {
+      var s0, s1;
+
+      peg$silentFails++;
+      s0 = peg$parseif();
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c0); }
+      }
+
+      return s0;
+    }
+
+    function peg$parseexpressions() {
+      var s0, s1, s2, s3, s4, s5, s6;
+
+      s0 = peg$currPos;
+      s1 = peg$parseexpression();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s4 = peg$c3;
+          peg$currPos++;
+        } else {
+          s4 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c4); }
+        }
+        if (s4 !== null) {
+          s5 = peg$parse_();
+          if (s5 !== null) {
+            s6 = peg$parseexpression();
+            if (s6 !== null) {
+              s4 = [s4, s5, s6];
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s4 = peg$c3;
+            peg$currPos++;
+          } else {
+            s4 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c4); }
+          }
+          if (s4 !== null) {
+            s5 = peg$parse_();
+            if (s5 !== null) {
+              s6 = peg$parseexpression();
+              if (s6 !== null) {
+                s4 = [s4, s5, s6];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c5(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseargs() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 40) {
+        s1 = peg$c6;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c7); }
+      }
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          if (input.charCodeAt(peg$currPos) === 41) {
+            s3 = peg$c8;
+            peg$currPos++;
+          } else {
+            s3 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c9); }
+          }
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c10();
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s1 = peg$c6;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c7); }
+        }
+        if (s1 !== null) {
+          s2 = peg$parseexpressions();
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s3 = peg$c8;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c9); }
+            }
+            if (s3 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c11(s2);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseif() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
+
+      s0 = peg$currPos;
+      s1 = peg$parseor();
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 63) {
+            s4 = peg$c13;
+            peg$currPos++;
+          } else {
+            s4 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c14); }
+          }
+          if (s4 !== null) {
+            s5 = peg$parse_();
+            if (s5 !== null) {
+              s6 = peg$parseexpression();
+              if (s6 !== null) {
+                s7 = peg$parse_();
+                if (s7 !== null) {
+                  if (input.charCodeAt(peg$currPos) === 58) {
+                    s8 = peg$c15;
+                    peg$currPos++;
+                  } else {
+                    s8 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c16); }
+                  }
+                  if (s8 !== null) {
+                    s9 = peg$parse_();
+                    if (s9 !== null) {
+                      s10 = peg$parseexpression();
+                      if (s10 !== null) {
+                        s4 = [s4, s5, s6, s7, s8, s9, s10];
+                        s3 = s4;
+                      } else {
+                        peg$currPos = s3;
+                        s3 = peg$c1;
+                      }
+                    } else {
+                      peg$currPos = s3;
+                      s3 = peg$c1;
+                    }
+                  } else {
+                    peg$currPos = s3;
+                    s3 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+          if (s3 === null) {
+            s3 = peg$c12;
+          }
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c17(s1,s3);
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseor() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parseand();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          if (input.substr(peg$currPos, 2) === peg$c18) {
+            s5 = peg$c18;
+            peg$currPos += 2;
+          } else {
+            s5 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c19); }
+          }
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parseand();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            if (input.substr(peg$currPos, 2) === peg$c18) {
+              s5 = peg$c18;
+              peg$currPos += 2;
+            } else {
+              s5 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c19); }
+            }
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parseand();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseand() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parsecomparison();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          if (input.substr(peg$currPos, 2) === peg$c21) {
+            s5 = peg$c21;
+            peg$currPos += 2;
+          } else {
+            s5 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c22); }
+          }
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parsecomparison();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            if (input.substr(peg$currPos, 2) === peg$c21) {
+              s5 = peg$c21;
+              peg$currPos += 2;
+            } else {
+              s5 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c22); }
+            }
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parsecomparison();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsecomparison() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+      s0 = peg$currPos;
+      s1 = peg$parsearithmetic();
+      if (s1 !== null) {
+        s2 = peg$currPos;
+        s3 = peg$parse_();
+        if (s3 !== null) {
+          s4 = peg$currPos;
+          if (input.substr(peg$currPos, 3) === peg$c23) {
+            s5 = peg$c23;
+            peg$currPos += 3;
+          } else {
+            s5 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c24); }
+          }
+          if (s5 === null) {
+            if (input.substr(peg$currPos, 2) === peg$c25) {
+              s5 = peg$c25;
+              peg$currPos += 2;
+            } else {
+              s5 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c26); }
+            }
+            if (s5 === null) {
+              if (input.substr(peg$currPos, 2) === peg$c27) {
+                s5 = peg$c27;
+                peg$currPos += 2;
+              } else {
+                s5 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c28); }
+              }
+              if (s5 === null) {
+                s5 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 60) {
+                  s6 = peg$c29;
+                  peg$currPos++;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c30); }
+                }
+                if (s6 !== null) {
+                  s7 = peg$currPos;
+                  peg$silentFails++;
+                  if (input.charCodeAt(peg$currPos) === 45) {
+                    s8 = peg$c31;
+                    peg$currPos++;
+                  } else {
+                    s8 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c32); }
+                  }
+                  peg$silentFails--;
+                  if (s8 === null) {
+                    s7 = peg$c12;
+                  } else {
+                    peg$currPos = s7;
+                    s7 = peg$c1;
+                  }
+                  if (s7 !== null) {
+                    s6 = [s6, s7];
+                    s5 = s6;
+                  } else {
+                    peg$currPos = s5;
+                    s5 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$c1;
+                }
+                if (s5 === null) {
+                  if (input.charCodeAt(peg$currPos) === 62) {
+                    s5 = peg$c33;
+                    peg$currPos++;
+                  } else {
+                    s5 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c34); }
+                  }
+                  if (s5 === null) {
+                    if (input.substr(peg$currPos, 2) === peg$c35) {
+                      s5 = peg$c35;
+                      peg$currPos += 2;
+                    } else {
+                      s5 = null;
+                      if (peg$silentFails === 0) { peg$fail(peg$c36); }
+                    }
+                    if (s5 === null) {
+                      if (input.substr(peg$currPos, 2) === peg$c37) {
+                        s5 = peg$c37;
+                        peg$currPos += 2;
+                      } else {
+                        s5 = null;
+                        if (peg$silentFails === 0) { peg$fail(peg$c38); }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (s5 !== null) {
+            s5 = input.substring(s4, peg$currPos);
+          }
+          s4 = s5;
+          if (s4 !== null) {
+            s5 = peg$parse_();
+            if (s5 !== null) {
+              s6 = peg$parsearithmetic();
+              if (s6 !== null) {
+                s3 = [s3, s4, s5, s6];
+                s2 = s3;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$c1;
+              }
+            } else {
+              peg$currPos = s2;
+              s2 = peg$c1;
+            }
+          } else {
+            peg$currPos = s2;
+            s2 = peg$c1;
+          }
+        } else {
+          peg$currPos = s2;
+          s2 = peg$c1;
+        }
+        if (s2 === null) {
+          s2 = peg$c12;
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c39(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsearithmetic() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parsemultiplicative();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          s5 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 43) {
+            s6 = peg$c40;
+            peg$currPos++;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c41); }
+          }
+          if (s6 === null) {
+            if (input.charCodeAt(peg$currPos) === 45) {
+              s6 = peg$c31;
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c32); }
+            }
+          }
+          if (s6 !== null) {
+            s6 = input.substring(s5, peg$currPos);
+          }
+          s5 = s6;
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parsemultiplicative();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            s5 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 43) {
+              s6 = peg$c40;
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c41); }
+            }
+            if (s6 === null) {
+              if (input.charCodeAt(peg$currPos) === 45) {
+                s6 = peg$c31;
+                peg$currPos++;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c32); }
+              }
+            }
+            if (s6 !== null) {
+              s6 = input.substring(s5, peg$currPos);
+            }
+            s5 = s6;
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parsemultiplicative();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsemultiplicative() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parseexponential();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          s5 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 42) {
+            s6 = peg$c42;
+            peg$currPos++;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c43); }
+          }
+          if (s6 === null) {
+            if (input.charCodeAt(peg$currPos) === 47) {
+              s6 = peg$c44;
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c45); }
+            }
+            if (s6 === null) {
+              if (input.charCodeAt(peg$currPos) === 37) {
+                s6 = peg$c46;
+                peg$currPos++;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c47); }
+              }
+              if (s6 === null) {
+                if (input.substr(peg$currPos, 3) === peg$c48) {
+                  s6 = peg$c48;
+                  peg$currPos += 3;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c49); }
+                }
+              }
+            }
+          }
+          if (s6 !== null) {
+            s6 = input.substring(s5, peg$currPos);
+          }
+          s5 = s6;
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parseexponential();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            s5 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 42) {
+              s6 = peg$c42;
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c43); }
+            }
+            if (s6 === null) {
+              if (input.charCodeAt(peg$currPos) === 47) {
+                s6 = peg$c44;
+                peg$currPos++;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c45); }
+              }
+              if (s6 === null) {
+                if (input.charCodeAt(peg$currPos) === 37) {
+                  s6 = peg$c46;
+                  peg$currPos++;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c47); }
+                }
+                if (s6 === null) {
+                  if (input.substr(peg$currPos, 3) === peg$c48) {
+                    s6 = peg$c48;
+                    peg$currPos += 3;
+                  } else {
+                    s6 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c49); }
+                  }
+                }
+              }
+            }
+            if (s6 !== null) {
+              s6 = input.substring(s5, peg$currPos);
+            }
+            s5 = s6;
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parseexponential();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseexponential() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parsedefault();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          s5 = peg$currPos;
+          if (input.substr(peg$currPos, 2) === peg$c50) {
+            s6 = peg$c50;
+            peg$currPos += 2;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c51); }
+          }
+          if (s6 === null) {
+            if (input.substr(peg$currPos, 2) === peg$c52) {
+              s6 = peg$c52;
+              peg$currPos += 2;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c53); }
+            }
+            if (s6 === null) {
+              if (input.substr(peg$currPos, 2) === peg$c54) {
+                s6 = peg$c54;
+                peg$currPos += 2;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c55); }
+              }
+            }
+          }
+          if (s6 !== null) {
+            s6 = input.substring(s5, peg$currPos);
+          }
+          s5 = s6;
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parsedefault();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            s5 = peg$currPos;
+            if (input.substr(peg$currPos, 2) === peg$c50) {
+              s6 = peg$c50;
+              peg$currPos += 2;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c51); }
+            }
+            if (s6 === null) {
+              if (input.substr(peg$currPos, 2) === peg$c52) {
+                s6 = peg$c52;
+                peg$currPos += 2;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c53); }
+              }
+              if (s6 === null) {
+                if (input.substr(peg$currPos, 2) === peg$c54) {
+                  s6 = peg$c54;
+                  peg$currPos += 2;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c55); }
+                }
+              }
+            }
+            if (s6 !== null) {
+              s6 = input.substring(s5, peg$currPos);
+            }
+            s5 = s6;
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parsedefault();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsedefault() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      s1 = peg$parseunary();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        s4 = peg$parse_();
+        if (s4 !== null) {
+          if (input.substr(peg$currPos, 2) === peg$c56) {
+            s5 = peg$c56;
+            peg$currPos += 2;
+          } else {
+            s5 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c57); }
+          }
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parseunary();
+              if (s7 !== null) {
+                s4 = [s4, s5, s6, s7];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parse_();
+          if (s4 !== null) {
+            if (input.substr(peg$currPos, 2) === peg$c56) {
+              s5 = peg$c56;
+              peg$currPos += 2;
+            } else {
+              s5 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c57); }
+            }
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parseunary();
+                if (s7 !== null) {
+                  s4 = [s4, s5, s6, s7];
+                  s3 = s4;
+                } else {
+                  peg$currPos = s3;
+                  s3 = peg$c1;
+                }
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c20(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseunary() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 33) {
+        s2 = peg$c58;
+        peg$currPos++;
+      } else {
+        s2 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c59); }
+      }
+      if (s2 === null) {
+        if (input.charCodeAt(peg$currPos) === 43) {
+          s2 = peg$c40;
+          peg$currPos++;
+        } else {
+          s2 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c41); }
+        }
+        if (s2 === null) {
+          if (input.charCodeAt(peg$currPos) === 45) {
+            s2 = peg$c31;
+            peg$currPos++;
+          } else {
+            s2 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c32); }
+          }
+        }
+      }
+      if (s2 !== null) {
+        s2 = input.substring(s1, peg$currPos);
+      }
+      s1 = s2;
+      if (s1 !== null) {
+        s2 = peg$parseunary();
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c60(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$parsepipe();
+      }
+
+      return s0;
+    }
+
+    function peg$parsepipe() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      s1 = peg$parsevalue();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$parsechain();
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$parsechain();
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c61(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsechain() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s1 = peg$c62;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c63); }
+      }
+      if (s1 !== null) {
+        s2 = peg$parsetail();
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c64(s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 91) {
+          s1 = peg$c65;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c66); }
+        }
+        if (s1 !== null) {
+          s2 = peg$parseexpression();
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 93) {
+              s3 = peg$c67;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c68); }
+            }
+            if (s3 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c69(s2);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsetail() {
+      var s0, s1, s2, s3, s4;
+
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parseword();
+      if (s2 !== null) {
+        s2 = input.substring(s1, peg$currPos);
+      }
+      s1 = s2;
+      if (s1 !== null) {
+        if (input.charCodeAt(peg$currPos) === 123) {
+          s2 = peg$c70;
+          peg$currPos++;
+        } else {
+          s2 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c71); }
+        }
+        if (s2 !== null) {
+          s3 = peg$parseexpression();
+          if (s3 !== null) {
+            if (input.charCodeAt(peg$currPos) === 125) {
+              s4 = peg$c72;
+              peg$currPos++;
+            } else {
+              s4 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c73); }
+            }
+            if (s4 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c74(s1,s3);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        s2 = peg$parseword();
+        if (s2 !== null) {
+          s2 = input.substring(s1, peg$currPos);
+        }
+        s1 = s2;
+        if (s1 !== null) {
+          s2 = peg$parseargs();
+          if (s2 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c75(s1,s2);
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+        if (s0 === null) {
+          s0 = peg$currPos;
+          s1 = peg$parsedigits();
+          if (s1 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c76(s1);
+          }
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+          if (s0 === null) {
+            s0 = peg$currPos;
+            s1 = peg$currPos;
+            s2 = peg$parseword();
+            if (s2 !== null) {
+              s2 = input.substring(s1, peg$currPos);
+            }
+            s1 = s2;
+            if (s1 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c77(s1);
+            }
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+            if (s0 === null) {
+              s0 = peg$currPos;
+              s1 = peg$parsearray();
+              if (s1 !== null) {
+                peg$reportedPos = s0;
+                s1 = peg$c78(s1);
+              }
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+              if (s0 === null) {
+                s0 = peg$currPos;
+                s1 = peg$parseobject();
+                if (s1 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c78(s1);
+                }
+                if (s1 === null) {
+                  peg$currPos = s0;
+                  s0 = s1;
+                } else {
+                  s0 = s1;
+                }
+                if (s0 === null) {
+                  s0 = peg$currPos;
+                  if (input.charCodeAt(peg$currPos) === 40) {
+                    s1 = peg$c6;
+                    peg$currPos++;
+                  } else {
+                    s1 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c7); }
+                  }
+                  if (s1 !== null) {
+                    s2 = peg$parseexpression();
+                    if (s2 !== null) {
+                      if (input.charCodeAt(peg$currPos) === 41) {
+                        s3 = peg$c8;
+                        peg$currPos++;
+                      } else {
+                        s3 = null;
+                        if (peg$silentFails === 0) { peg$fail(peg$c9); }
+                      }
+                      if (s3 !== null) {
+                        peg$reportedPos = s0;
+                        s1 = peg$c78(s2);
+                        if (s1 === null) {
+                          peg$currPos = s0;
+                          s0 = s1;
+                        } else {
+                          s0 = s1;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c1;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$c1;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$c1;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsevalue() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$parsearray();
+      if (s0 === null) {
+        s0 = peg$parseobject();
+        if (s0 === null) {
+          s0 = peg$parsestring();
+          if (s0 === null) {
+            s0 = peg$parsenumber();
+            if (s0 === null) {
+              s0 = peg$currPos;
+              if (input.substr(peg$currPos, 4) === peg$c79) {
+                s1 = peg$c79;
+                peg$currPos += 4;
+              } else {
+                s1 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c80); }
+              }
+              if (s1 !== null) {
+                peg$reportedPos = s0;
+                s1 = peg$c81();
+              }
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+              if (s0 === null) {
+                s0 = peg$currPos;
+                if (input.substr(peg$currPos, 4) === peg$c82) {
+                  s1 = peg$c82;
+                  peg$currPos += 4;
+                } else {
+                  s1 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c83); }
+                }
+                if (s1 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c84();
+                }
+                if (s1 === null) {
+                  peg$currPos = s0;
+                  s0 = s1;
+                } else {
+                  s0 = s1;
+                }
+                if (s0 === null) {
+                  s0 = peg$currPos;
+                  if (input.substr(peg$currPos, 5) === peg$c85) {
+                    s1 = peg$c85;
+                    peg$currPos += 5;
+                  } else {
+                    s1 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c86); }
+                  }
+                  if (s1 !== null) {
+                    peg$reportedPos = s0;
+                    s1 = peg$c87();
+                  }
+                  if (s1 === null) {
+                    peg$currPos = s0;
+                    s0 = s1;
+                  } else {
+                    s0 = s1;
+                  }
+                  if (s0 === null) {
+                    s0 = peg$currPos;
+                    if (input.substr(peg$currPos, 4) === peg$c88) {
+                      s1 = peg$c88;
+                      peg$currPos += 4;
+                    } else {
+                      s1 = null;
+                      if (peg$silentFails === 0) { peg$fail(peg$c89); }
+                    }
+                    if (s1 !== null) {
+                      peg$reportedPos = s0;
+                      s1 = peg$c90();
+                    }
+                    if (s1 === null) {
+                      peg$currPos = s0;
+                      s0 = s1;
+                    } else {
+                      s0 = s1;
+                    }
+                    if (s0 === null) {
+                      s0 = peg$currPos;
+                      if (input.charCodeAt(peg$currPos) === 64) {
+                        s1 = peg$c91;
+                        peg$currPos++;
+                      } else {
+                        s1 = null;
+                        if (peg$silentFails === 0) { peg$fail(peg$c92); }
+                      }
+                      if (s1 !== null) {
+                        s2 = peg$currPos;
+                        s3 = peg$parselabel();
+                        if (s3 !== null) {
+                          s3 = input.substring(s2, peg$currPos);
+                        }
+                        s2 = s3;
+                        if (s2 !== null) {
+                          peg$reportedPos = s0;
+                          s1 = peg$c93(s2);
+                          if (s1 === null) {
+                            peg$currPos = s0;
+                            s0 = s1;
+                          } else {
+                            s0 = s1;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$c1;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c1;
+                      }
+                      if (s0 === null) {
+                        s0 = peg$currPos;
+                        if (input.charCodeAt(peg$currPos) === 36) {
+                          s1 = peg$c94;
+                          peg$currPos++;
+                        } else {
+                          s1 = null;
+                          if (peg$silentFails === 0) { peg$fail(peg$c95); }
+                        }
+                        if (s1 !== null) {
+                          s2 = peg$currPos;
+                          s3 = peg$parseword();
+                          if (s3 !== null) {
+                            s3 = input.substring(s2, peg$currPos);
+                          }
+                          s2 = s3;
+                          if (s2 !== null) {
+                            peg$reportedPos = s0;
+                            s1 = peg$c96(s2);
+                            if (s1 === null) {
+                              peg$currPos = s0;
+                              s0 = s1;
+                            } else {
+                              s0 = s1;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$c1;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$c1;
+                        }
+                        if (s0 === null) {
+                          s0 = peg$currPos;
+                          if (input.charCodeAt(peg$currPos) === 36) {
+                            s1 = peg$c94;
+                            peg$currPos++;
+                          } else {
+                            s1 = null;
+                            if (peg$silentFails === 0) { peg$fail(peg$c95); }
+                          }
+                          if (s1 !== null) {
+                            peg$reportedPos = s0;
+                            s1 = peg$c97();
+                          }
+                          if (s1 === null) {
+                            peg$currPos = s0;
+                            s0 = s1;
+                          } else {
+                            s0 = s1;
+                          }
+                          if (s0 === null) {
+                            s0 = peg$currPos;
+                            if (input.charCodeAt(peg$currPos) === 35) {
+                              s1 = peg$c98;
+                              peg$currPos++;
+                            } else {
+                              s1 = null;
+                              if (peg$silentFails === 0) { peg$fail(peg$c99); }
+                            }
+                            if (s1 !== null) {
+                              s2 = peg$currPos;
+                              s3 = peg$parseword();
+                              if (s3 !== null) {
+                                s3 = input.substring(s2, peg$currPos);
+                              }
+                              s2 = s3;
+                              if (s2 !== null) {
+                                peg$reportedPos = s0;
+                                s1 = peg$c100(s2);
+                                if (s1 === null) {
+                                  peg$currPos = s0;
+                                  s0 = s1;
+                                } else {
+                                  s0 = s1;
+                                }
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$c1;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$c1;
+                            }
+                            if (s0 === null) {
+                              s0 = peg$currPos;
+                              if (input.charCodeAt(peg$currPos) === 38) {
+                                s1 = peg$c101;
+                                peg$currPos++;
+                              } else {
+                                s1 = null;
+                                if (peg$silentFails === 0) { peg$fail(peg$c102); }
+                              }
+                              if (s1 !== null) {
+                                s2 = peg$currPos;
+                                s3 = peg$parseword();
+                                if (s3 !== null) {
+                                  s3 = input.substring(s2, peg$currPos);
+                                }
+                                s2 = s3;
+                                if (s2 !== null) {
+                                  s3 = peg$parseargs();
+                                  if (s3 !== null) {
+                                    peg$reportedPos = s0;
+                                    s1 = peg$c103(s2,s3);
+                                    if (s1 === null) {
+                                      peg$currPos = s0;
+                                      s0 = s1;
+                                    } else {
+                                      s0 = s1;
+                                    }
+                                  } else {
+                                    peg$currPos = s0;
+                                    s0 = peg$c1;
+                                  }
+                                } else {
+                                  peg$currPos = s0;
+                                  s0 = peg$c1;
+                                }
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$c1;
+                              }
+                              if (s0 === null) {
+                                s0 = peg$currPos;
+                                if (input.charCodeAt(peg$currPos) === 94) {
+                                  s1 = peg$c104;
+                                  peg$currPos++;
+                                } else {
+                                  s1 = null;
+                                  if (peg$silentFails === 0) { peg$fail(peg$c105); }
+                                }
+                                if (s1 !== null) {
+                                  s2 = peg$parsevalue();
+                                  if (s2 !== null) {
+                                    peg$reportedPos = s0;
+                                    s1 = peg$c106(s2);
+                                    if (s1 === null) {
+                                      peg$currPos = s0;
+                                      s0 = s1;
+                                    } else {
+                                      s0 = s1;
+                                    }
+                                  } else {
+                                    peg$currPos = s0;
+                                    s0 = peg$c1;
+                                  }
+                                } else {
+                                  peg$currPos = s0;
+                                  s0 = peg$c1;
+                                }
+                                if (s0 === null) {
+                                  s0 = peg$currPos;
+                                  if (input.charCodeAt(peg$currPos) === 40) {
+                                    s1 = peg$c6;
+                                    peg$currPos++;
+                                  } else {
+                                    s1 = null;
+                                    if (peg$silentFails === 0) { peg$fail(peg$c7); }
+                                  }
+                                  if (s1 !== null) {
+                                    s2 = peg$parseexpression();
+                                    if (s2 !== null) {
+                                      if (input.charCodeAt(peg$currPos) === 41) {
+                                        s3 = peg$c8;
+                                        peg$currPos++;
+                                      } else {
+                                        s3 = null;
+                                        if (peg$silentFails === 0) { peg$fail(peg$c9); }
+                                      }
+                                      if (s3 !== null) {
+                                        peg$reportedPos = s0;
+                                        s1 = peg$c107(s2);
+                                        if (s1 === null) {
+                                          peg$currPos = s0;
+                                          s0 = s1;
+                                        } else {
+                                          s0 = s1;
+                                        }
+                                      } else {
+                                        peg$currPos = s0;
+                                        s0 = peg$c1;
+                                      }
+                                    } else {
+                                      peg$currPos = s0;
+                                      s0 = peg$c1;
+                                    }
+                                  } else {
+                                    peg$currPos = s0;
+                                    s0 = peg$c1;
+                                  }
+                                  if (s0 === null) {
+                                    s0 = peg$currPos;
+                                    s1 = peg$parsetail();
+                                    if (s1 !== null) {
+                                      peg$reportedPos = s0;
+                                      s1 = peg$c108(s1);
+                                    }
+                                    if (s1 === null) {
+                                      peg$currPos = s0;
+                                      s0 = s1;
+                                    } else {
+                                      s0 = s1;
+                                    }
+                                    if (s0 === null) {
+                                      s0 = peg$currPos;
+                                      s1 = [];
+                                      if (s1 !== null) {
+                                        peg$reportedPos = s0;
+                                        s1 = peg$c109();
+                                      }
+                                      if (s1 === null) {
+                                        peg$currPos = s0;
+                                        s0 = s1;
+                                      } else {
+                                        s0 = s1;
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseword() {
+      var s0, s1;
+
+      peg$silentFails++;
+      s0 = [];
+      if (peg$c111.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c112); }
+      }
+      if (s1 !== null) {
+        while (s1 !== null) {
+          s0.push(s1);
+          if (peg$c111.test(input.charAt(peg$currPos))) {
+            s1 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s1 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c112); }
+          }
+        }
+      } else {
+        s0 = peg$c1;
+      }
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c110); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsestring() {
+      var s0, s1, s2, s3;
+
+      peg$silentFails++;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 39) {
+        s1 = peg$c114;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c115); }
+      }
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$parsetickedChar();
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$parsetickedChar();
+        }
+        if (s2 !== null) {
+          if (input.charCodeAt(peg$currPos) === 39) {
+            s3 = peg$c114;
+            peg$currPos++;
+          } else {
+            s3 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c115); }
+          }
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c116(s2);
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 34) {
+          s1 = peg$c117;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c118); }
+        }
+        if (s1 !== null) {
+          s2 = [];
+          s3 = peg$parsequotedChar();
+          while (s3 !== null) {
+            s2.push(s3);
+            s3 = peg$parsequotedChar();
+          }
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 34) {
+              s3 = peg$c117;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c118); }
+            }
+            if (s3 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c116(s2);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      }
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c113); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsetickedChar() {
+      var s0, s1;
+
+      if (peg$c119.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c120); }
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c121) {
+          s1 = peg$c121;
+          peg$currPos += 2;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c122); }
+        }
+        if (s1 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c123();
+        }
+        if (s1 === null) {
+          peg$currPos = s0;
+          s0 = s1;
+        } else {
+          s0 = s1;
+        }
+        if (s0 === null) {
+          s0 = peg$parseescape();
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsequotedChar() {
+      var s0, s1;
+
+      if (peg$c124.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c125); }
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c126) {
+          s1 = peg$c126;
+          peg$currPos += 2;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c127); }
+        }
+        if (s1 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c128();
+        }
+        if (s1 === null) {
+          peg$currPos = s0;
+          s0 = s1;
+        } else {
+          s0 = s1;
+        }
+        if (s0 === null) {
+          s0 = peg$parseescape();
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseescape() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c129) {
+        s1 = peg$c129;
+        peg$currPos += 2;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c130); }
+      }
+      if (s1 !== null) {
+        peg$reportedPos = s0;
+        s1 = peg$c131();
+      }
+      if (s1 === null) {
+        peg$currPos = s0;
+        s0 = s1;
+      } else {
+        s0 = s1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c132) {
+          s1 = peg$c132;
+          peg$currPos += 2;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c133); }
+        }
+        if (s1 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c134();
+        }
+        if (s1 === null) {
+          peg$currPos = s0;
+          s0 = s1;
+        } else {
+          s0 = s1;
+        }
+        if (s0 === null) {
+          s0 = peg$currPos;
+          if (input.substr(peg$currPos, 2) === peg$c135) {
+            s1 = peg$c135;
+            peg$currPos += 2;
+          } else {
+            s1 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c136); }
+          }
+          if (s1 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c137();
+          }
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+          if (s0 === null) {
+            s0 = peg$currPos;
+            if (input.substr(peg$currPos, 2) === peg$c138) {
+              s1 = peg$c138;
+              peg$currPos += 2;
+            } else {
+              s1 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c139); }
+            }
+            if (s1 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c140();
+            }
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+            if (s0 === null) {
+              s0 = peg$currPos;
+              if (input.substr(peg$currPos, 2) === peg$c141) {
+                s1 = peg$c141;
+                peg$currPos += 2;
+              } else {
+                s1 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c142); }
+              }
+              if (s1 !== null) {
+                peg$reportedPos = s0;
+                s1 = peg$c143();
+              }
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+              if (s0 === null) {
+                s0 = peg$currPos;
+                if (input.substr(peg$currPos, 2) === peg$c144) {
+                  s1 = peg$c144;
+                  peg$currPos += 2;
+                } else {
+                  s1 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c145); }
+                }
+                if (s1 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c146();
+                }
+                if (s1 === null) {
+                  peg$currPos = s0;
+                  s0 = s1;
+                } else {
+                  s0 = s1;
+                }
+                if (s0 === null) {
+                  s0 = peg$currPos;
+                  if (input.substr(peg$currPos, 2) === peg$c147) {
+                    s1 = peg$c147;
+                    peg$currPos += 2;
+                  } else {
+                    s1 = null;
+                    if (peg$silentFails === 0) { peg$fail(peg$c148); }
+                  }
+                  if (s1 !== null) {
+                    peg$reportedPos = s0;
+                    s1 = peg$c149();
+                  }
+                  if (s1 === null) {
+                    peg$currPos = s0;
+                    s0 = s1;
+                  } else {
+                    s0 = s1;
+                  }
+                  if (s0 === null) {
+                    s0 = peg$currPos;
+                    if (input.substr(peg$currPos, 2) === peg$c150) {
+                      s1 = peg$c150;
+                      peg$currPos += 2;
+                    } else {
+                      s1 = null;
+                      if (peg$silentFails === 0) { peg$fail(peg$c151); }
+                    }
+                    if (s1 !== null) {
+                      peg$reportedPos = s0;
+                      s1 = peg$c152();
+                    }
+                    if (s1 === null) {
+                      peg$currPos = s0;
+                      s0 = s1;
+                    } else {
+                      s0 = s1;
+                    }
+                    if (s0 === null) {
+                      s0 = peg$currPos;
+                      if (input.substr(peg$currPos, 2) === peg$c153) {
+                        s1 = peg$c153;
+                        peg$currPos += 2;
+                      } else {
+                        s1 = null;
+                        if (peg$silentFails === 0) { peg$fail(peg$c154); }
+                      }
+                      if (s1 !== null) {
+                        s2 = peg$currPos;
+                        s3 = peg$currPos;
+                        s4 = peg$parsehexDigit();
+                        if (s4 !== null) {
+                          s5 = peg$parsehexDigit();
+                          if (s5 !== null) {
+                            s6 = peg$parsehexDigit();
+                            if (s6 !== null) {
+                              s7 = peg$parsehexDigit();
+                              if (s7 !== null) {
+                                s4 = [s4, s5, s6, s7];
+                                s3 = s4;
+                              } else {
+                                peg$currPos = s3;
+                                s3 = peg$c1;
+                              }
+                            } else {
+                              peg$currPos = s3;
+                              s3 = peg$c1;
+                            }
+                          } else {
+                            peg$currPos = s3;
+                            s3 = peg$c1;
+                          }
+                        } else {
+                          peg$currPos = s3;
+                          s3 = peg$c1;
+                        }
+                        if (s3 !== null) {
+                          s3 = input.substring(s2, peg$currPos);
+                        }
+                        s2 = s3;
+                        if (s2 !== null) {
+                          peg$reportedPos = s0;
+                          s1 = peg$c155(s2);
+                          if (s1 === null) {
+                            peg$currPos = s0;
+                            s0 = s1;
+                          } else {
+                            s0 = s1;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$c1;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c1;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsehexDigit() {
+      var s0;
+
+      if (peg$c156.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c157); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsearray() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s1 = peg$c65;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c66); }
+      }
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s3 = peg$c67;
+            peg$currPos++;
+          } else {
+            s3 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c68); }
+          }
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c158();
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 91) {
+          s1 = peg$c65;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c66); }
+        }
+        if (s1 !== null) {
+          s2 = peg$parseexpressions();
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 93) {
+              s3 = peg$c67;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c68); }
+            }
+            if (s3 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c159(s2);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseobject() {
+      var s0, s1, s2, s3, s4, s5;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 123) {
+        s1 = peg$c70;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c71); }
+      }
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s3 = peg$c72;
+            peg$currPos++;
+          } else {
+            s3 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c73); }
+          }
+          if (s3 !== null) {
+            s4 = peg$parse_();
+            if (s4 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c160();
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 123) {
+          s1 = peg$c70;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c71); }
+        }
+        if (s1 !== null) {
+          s2 = peg$parse_();
+          if (s2 !== null) {
+            s3 = peg$parsepairs();
+            if (s3 !== null) {
+              if (input.charCodeAt(peg$currPos) === 125) {
+                s4 = peg$c72;
+                peg$currPos++;
+              } else {
+                s4 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c73); }
+              }
+              if (s4 !== null) {
+                s5 = peg$parse_();
+                if (s5 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c161(s3);
+                  if (s1 === null) {
+                    peg$currPos = s0;
+                    s0 = s1;
+                  } else {
+                    s0 = s1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsepairs() {
+      var s0, s1, s2, s3, s4, s5, s6;
+
+      s0 = peg$currPos;
+      s1 = peg$parsepair();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s4 = peg$c3;
+          peg$currPos++;
+        } else {
+          s4 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c4); }
+        }
+        if (s4 !== null) {
+          s5 = peg$parse_();
+          if (s5 !== null) {
+            s6 = peg$parsepair();
+            if (s6 !== null) {
+              s4 = [s4, s5, s6];
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s4 = peg$c3;
+            peg$currPos++;
+          } else {
+            s4 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c4); }
+          }
+          if (s4 !== null) {
+            s5 = peg$parse_();
+            if (s5 !== null) {
+              s6 = peg$parsepair();
+              if (s6 !== null) {
+                s4 = [s4, s5, s6];
+                s3 = s4;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$c1;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c162(s1,s2);
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsepair() {
+      var s0, s1, s2, s3, s4;
+
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parseword();
+      if (s2 !== null) {
+        s2 = input.substring(s1, peg$currPos);
+      }
+      s1 = s2;
+      if (s1 !== null) {
+        if (input.charCodeAt(peg$currPos) === 58) {
+          s2 = peg$c15;
+          peg$currPos++;
+        } else {
+          s2 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c16); }
+        }
+        if (s2 !== null) {
+          s3 = peg$parse_();
+          if (s3 !== null) {
+            s4 = peg$parseexpression();
+            if (s4 !== null) {
+              peg$reportedPos = s0;
+              s1 = peg$c163(s1,s4);
+              if (s1 === null) {
+                peg$currPos = s0;
+                s0 = s1;
+              } else {
+                s0 = s1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsenumber() {
+      var s0, s1, s2;
+
+      peg$silentFails++;
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parsenumberPattern();
+      if (s2 !== null) {
+        s2 = input.substring(s1, peg$currPos);
+      }
+      s1 = s2;
+      if (s1 !== null) {
+        peg$reportedPos = s0;
+        s1 = peg$c165(s1);
+      }
+      if (s1 === null) {
+        peg$currPos = s0;
+        s0 = s1;
+      } else {
+        s0 = s1;
+      }
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c164); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsenumberPattern() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      s1 = peg$parseint();
+      if (s1 !== null) {
+        s2 = peg$parsefrac();
+        if (s2 !== null) {
+          s3 = peg$parseexp();
+          if (s3 !== null) {
+            s1 = [s1, s2, s3];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        s1 = peg$parseint();
+        if (s1 !== null) {
+          s2 = peg$parsefrac();
+          if (s2 !== null) {
+            s1 = [s1, s2];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+        if (s0 === null) {
+          s0 = peg$currPos;
+          s1 = peg$parseint();
+          if (s1 !== null) {
+            s2 = peg$parseexp();
+            if (s2 !== null) {
+              s1 = [s1, s2];
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+          if (s0 === null) {
+            s0 = peg$parseint();
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseint() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      s1 = peg$parsedigit19();
+      if (s1 !== null) {
+        s2 = peg$parsedigits();
+        if (s2 !== null) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$parsedigit();
+        if (s0 === null) {
+          s0 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 45) {
+            s1 = peg$c31;
+            peg$currPos++;
+          } else {
+            s1 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c32); }
+          }
+          if (s1 !== null) {
+            s2 = peg$parsedigit19();
+            if (s2 !== null) {
+              s3 = peg$parsedigits();
+              if (s3 !== null) {
+                s1 = [s1, s2, s3];
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+          if (s0 === null) {
+            s0 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 45) {
+              s1 = peg$c31;
+              peg$currPos++;
+            } else {
+              s1 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c32); }
+            }
+            if (s1 !== null) {
+              s2 = peg$parsedigit();
+              if (s2 !== null) {
+                s1 = [s1, s2];
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsefrac() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s1 = peg$c62;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c63); }
+      }
+      if (s1 !== null) {
+        s2 = peg$parsedigits();
+        if (s2 !== null) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseexp() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      s1 = peg$parsee();
+      if (s1 !== null) {
+        s2 = peg$parsedigits();
+        if (s2 !== null) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsedigits() {
+      var s0, s1;
+
+      s0 = [];
+      s1 = peg$parsedigit();
+      if (s1 !== null) {
+        while (s1 !== null) {
+          s0.push(s1);
+          s1 = peg$parsedigit();
+        }
+      } else {
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsee() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      if (peg$c166.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c167); }
+      }
+      if (s1 !== null) {
+        if (peg$c168.test(input.charAt(peg$currPos))) {
+          s2 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s2 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c169); }
+        }
+        if (s2 === null) {
+          s2 = peg$c12;
+        }
+        if (s2 !== null) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsedigit() {
+      var s0;
+
+      if (peg$c170.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c171); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsedigit19() {
+      var s0;
+
+      if (peg$c172.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c173); }
+      }
+
+      return s0;
+    }
+
+    function peg$parse_() {
+      var s0, s1;
+
+      s0 = [];
+      s1 = peg$parsewhiteSpace();
+      if (s1 === null) {
+        s1 = peg$parselineTerminator();
+      }
+      while (s1 !== null) {
+        s0.push(s1);
+        s1 = peg$parsewhiteSpace();
+        if (s1 === null) {
+          s1 = peg$parselineTerminator();
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsewhiteSpace() {
+      var s0, s1;
+
+      peg$silentFails++;
+      if (peg$c175.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c176); }
+      }
+      if (s0 === null) {
+        if (peg$c177.test(input.charAt(peg$currPos))) {
+          s0 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s0 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c178); }
+        }
+      }
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c174); }
+      }
+
+      return s0;
+    }
+
+    function peg$parselineTerminator() {
+      var s0, s1;
+
+      peg$silentFails++;
+      if (peg$c180.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c181); }
+      }
+      peg$silentFails--;
+      if (s0 === null) {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c179); }
+      }
+
+      return s0;
+    }
+
+    function peg$parsecomment() {
+      var s0, s1, s2, s3, s4, s5, s6;
+
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c182) {
+        s1 = peg$c182;
+        peg$currPos += 2;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c183); }
+      }
+      if (s1 !== null) {
+        s2 = peg$currPos;
+        s3 = [];
+        s4 = peg$currPos;
+        s5 = peg$currPos;
+        peg$silentFails++;
+        if (input.substr(peg$currPos, 2) === peg$c184) {
+          s6 = peg$c184;
+          peg$currPos += 2;
+        } else {
+          s6 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c185); }
+        }
+        peg$silentFails--;
+        if (s6 === null) {
+          s5 = peg$c12;
+        } else {
+          peg$currPos = s5;
+          s5 = peg$c1;
+        }
+        if (s5 !== null) {
+          if (input.length > peg$currPos) {
+            s6 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c186); }
+          }
+          if (s6 !== null) {
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$c1;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$c1;
+        }
+        while (s4 !== null) {
+          s3.push(s4);
+          s4 = peg$currPos;
+          s5 = peg$currPos;
+          peg$silentFails++;
+          if (input.substr(peg$currPos, 2) === peg$c184) {
+            s6 = peg$c184;
+            peg$currPos += 2;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c185); }
+          }
+          peg$silentFails--;
+          if (s6 === null) {
+            s5 = peg$c12;
+          } else {
+            peg$currPos = s5;
+            s5 = peg$c1;
+          }
+          if (s5 !== null) {
+            if (input.length > peg$currPos) {
+              s6 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c186); }
+            }
+            if (s6 !== null) {
+              s5 = [s5, s6];
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$c1;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$c1;
+          }
+        }
+        if (s3 !== null) {
+          s3 = input.substring(s2, peg$currPos);
+        }
+        s2 = s3;
+        if (s2 !== null) {
+          if (input.substr(peg$currPos, 2) === peg$c184) {
+            s3 = peg$c184;
+            peg$currPos += 2;
+          } else {
+            s3 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c185); }
+          }
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c187(s2);
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsesheet() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      s1 = peg$parse_();
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$parseblock();
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$parseblock();
+        }
+        if (s2 !== null) {
+          s3 = peg$parse_();
+          if (s3 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c188(s2);
+            if (s1 === null) {
+              peg$currPos = s0;
+              s0 = s1;
+            } else {
+              s0 = s1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseblock() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 64) {
+        s1 = peg$c91;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c92); }
+      }
+      if (s1 !== null) {
+        s2 = peg$currPos;
+        s3 = peg$parselabel();
+        if (s3 !== null) {
+          s3 = input.substring(s2, peg$currPos);
+        }
+        s2 = s3;
+        if (s2 !== null) {
+          s3 = peg$parse_();
+          if (s3 !== null) {
+            s4 = peg$parseannotation();
+            if (s4 === null) {
+              s4 = peg$c12;
+            }
+            if (s4 !== null) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s5 = peg$c70;
+                peg$currPos++;
+              } else {
+                s5 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c71); }
+              }
+              if (s5 !== null) {
+                s6 = peg$parse_();
+                if (s6 !== null) {
+                  s7 = peg$parsestatements();
+                  if (s7 !== null) {
+                    if (input.charCodeAt(peg$currPos) === 125) {
+                      s8 = peg$c72;
+                      peg$currPos++;
+                    } else {
+                      s8 = null;
+                      if (peg$silentFails === 0) { peg$fail(peg$c73); }
+                    }
+                    if (s8 !== null) {
+                      s9 = peg$parse_();
+                      if (s9 !== null) {
+                        peg$reportedPos = s0;
+                        s1 = peg$c189(s2,s4,s7);
+                        if (s1 === null) {
+                          peg$currPos = s0;
+                          s0 = s1;
+                        } else {
+                          s0 = s1;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c1;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$c1;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseannotation() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 60) {
+        s1 = peg$c29;
+        peg$currPos++;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c30); }
+      }
+      if (s1 === null) {
+        if (input.charCodeAt(peg$currPos) === 58) {
+          s1 = peg$c15;
+          peg$currPos++;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c16); }
+        }
+      }
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          s3 = peg$parsestring();
+          if (s3 === null) {
+            s3 = peg$c12;
+          }
+          if (s3 !== null) {
+            s4 = peg$parse_();
+            if (s4 !== null) {
+              s5 = peg$currPos;
+              s6 = peg$currPos;
+              peg$silentFails++;
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s7 = peg$c70;
+                peg$currPos++;
+              } else {
+                s7 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c71); }
+              }
+              peg$silentFails--;
+              if (s7 === null) {
+                s6 = peg$c12;
+              } else {
+                peg$currPos = s6;
+                s6 = peg$c1;
+              }
+              if (s6 !== null) {
+                s7 = peg$parseexpression();
+                if (s7 !== null) {
+                  s6 = [s6, s7];
+                  s5 = s6;
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$c1;
+                }
+              } else {
+                peg$currPos = s5;
+                s5 = peg$c1;
+              }
+              if (s5 === null) {
+                s5 = peg$c12;
+              }
+              if (s5 !== null) {
+                s6 = peg$parse_();
+                if (s6 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c190(s1,s3,s5);
+                  if (s1 === null) {
+                    peg$currPos = s0;
+                    s0 = s1;
+                  } else {
+                    s0 = s1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        s1 = peg$parse_();
+        if (s1 !== null) {
+          peg$reportedPos = s0;
+          s1 = peg$c191();
+        }
+        if (s1 === null) {
+          peg$currPos = s0;
+          s0 = s1;
+        } else {
+          s0 = s1;
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parselabel() {
+      var s0, s1, s2, s3, s4, s5, s6;
+
+      s0 = peg$currPos;
+      s1 = [];
+      if (peg$c192.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s2 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c193); }
+      }
+      if (s2 !== null) {
+        while (s2 !== null) {
+          s1.push(s2);
+          if (peg$c192.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s2 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c193); }
+          }
+        }
+      } else {
+        s1 = peg$c1;
+      }
+      if (s1 !== null) {
+        s2 = [];
+        s3 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 58) {
+          s4 = peg$c15;
+          peg$currPos++;
+        } else {
+          s4 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c16); }
+        }
+        if (s4 !== null) {
+          s5 = [];
+          if (peg$c192.test(input.charAt(peg$currPos))) {
+            s6 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s6 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c193); }
+          }
+          if (s6 !== null) {
+            while (s6 !== null) {
+              s5.push(s6);
+              if (peg$c192.test(input.charAt(peg$currPos))) {
+                s6 = input.charAt(peg$currPos);
+                peg$currPos++;
+              } else {
+                s6 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c193); }
+              }
+            }
+          } else {
+            s5 = peg$c1;
+          }
+          if (s5 !== null) {
+            s4 = [s4, s5];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$c1;
+        }
+        while (s3 !== null) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c15;
+            peg$currPos++;
+          } else {
+            s4 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c16); }
+          }
+          if (s4 !== null) {
+            s5 = [];
+            if (peg$c192.test(input.charAt(peg$currPos))) {
+              s6 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s6 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c193); }
+            }
+            if (s6 !== null) {
+              while (s6 !== null) {
+                s5.push(s6);
+                if (peg$c192.test(input.charAt(peg$currPos))) {
+                  s6 = input.charAt(peg$currPos);
+                  peg$currPos++;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c193); }
+                }
+              }
+            } else {
+              s5 = peg$c1;
+            }
+            if (s5 !== null) {
+              s4 = [s4, s5];
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$c1;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$c1;
+          }
+        }
+        if (s2 !== null) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsestatements() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+      s0 = peg$currPos;
+      s1 = peg$parsestatement();
+      if (s1 !== null) {
+        s2 = peg$parse_();
+        if (s2 !== null) {
+          s3 = [];
+          s4 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 59) {
+            s5 = peg$c194;
+            peg$currPos++;
+          } else {
+            s5 = null;
+            if (peg$silentFails === 0) { peg$fail(peg$c195); }
+          }
+          if (s5 !== null) {
+            s6 = peg$parse_();
+            if (s6 !== null) {
+              s7 = peg$parsestatement();
+              if (s7 !== null) {
+                s8 = peg$parse_();
+                if (s8 !== null) {
+                  s5 = [s5, s6, s7, s8];
+                  s4 = s5;
+                } else {
+                  peg$currPos = s4;
+                  s4 = peg$c1;
+                }
+              } else {
+                peg$currPos = s4;
+                s4 = peg$c1;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$c1;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$c1;
+          }
+          while (s4 !== null) {
+            s3.push(s4);
+            s4 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s5 = peg$c194;
+              peg$currPos++;
+            } else {
+              s5 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c195); }
+            }
+            if (s5 !== null) {
+              s6 = peg$parse_();
+              if (s6 !== null) {
+                s7 = peg$parsestatement();
+                if (s7 !== null) {
+                  s8 = peg$parse_();
+                  if (s8 !== null) {
+                    s5 = [s5, s6, s7, s8];
+                    s4 = s5;
+                  } else {
+                    peg$currPos = s4;
+                    s4 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s4;
+                  s4 = peg$c1;
+                }
+              } else {
+                peg$currPos = s4;
+                s4 = peg$c1;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$c1;
+            }
+          }
+          if (s3 !== null) {
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s4 = peg$c194;
+              peg$currPos++;
+            } else {
+              s4 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c195); }
+            }
+            if (s4 === null) {
+              s4 = peg$c12;
+            }
+            if (s4 !== null) {
+              s5 = peg$parse_();
+              if (s5 !== null) {
+                peg$reportedPos = s0;
+                s1 = peg$c5(s1,s3);
+                if (s1 === null) {
+                  peg$currPos = s0;
+                  s0 = s1;
+                } else {
+                  s0 = s1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        s1 = peg$parsestatement();
+        if (s1 !== null) {
+          s2 = peg$parse_();
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s3 = peg$c194;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c195); }
+            }
+            if (s3 === null) {
+              s3 = peg$c12;
+            }
+            if (s3 !== null) {
+              s4 = peg$parse_();
+              if (s4 !== null) {
+                peg$reportedPos = s0;
+                s1 = peg$c196(s1);
+                if (s1 === null) {
+                  peg$currPos = s0;
+                  s0 = s1;
+                } else {
+                  s0 = s1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+        if (s0 === null) {
+          s0 = peg$currPos;
+          s1 = peg$parse_();
+          if (s1 !== null) {
+            peg$reportedPos = s0;
+            s1 = peg$c10();
+          }
+          if (s1 === null) {
+            peg$currPos = s0;
+            s0 = s1;
+          } else {
+            s0 = s1;
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsestatement() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16;
+
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c197) {
+        s1 = peg$c197;
+        peg$currPos += 2;
+      } else {
+        s1 = null;
+        if (peg$silentFails === 0) { peg$fail(peg$c198); }
+      }
+      if (s1 === null) {
+        if (input.substr(peg$currPos, 6) === peg$c199) {
+          s1 = peg$c199;
+          peg$currPos += 6;
+        } else {
+          s1 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c200); }
+        }
+      }
+      if (s1 !== null) {
+        if (input.charCodeAt(peg$currPos) === 32) {
+          s2 = peg$c201;
+          peg$currPos++;
+        } else {
+          s2 = null;
+          if (peg$silentFails === 0) { peg$fail(peg$c202); }
+        }
+        if (s2 !== null) {
+          s3 = peg$parse_();
+          if (s3 !== null) {
+            s4 = peg$currPos;
+            s5 = peg$parseword();
+            if (s5 !== null) {
+              s5 = input.substring(s4, peg$currPos);
+            }
+            s4 = s5;
+            if (s4 !== null) {
+              s5 = peg$parse_();
+              if (s5 !== null) {
+                if (input.substr(peg$currPos, 2) === peg$c203) {
+                  s6 = peg$c203;
+                  peg$currPos += 2;
+                } else {
+                  s6 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c204); }
+                }
+                if (s6 !== null) {
+                  s7 = peg$parse_();
+                  if (s7 !== null) {
+                    s8 = peg$parseexpression();
+                    if (s8 !== null) {
+                      s9 = peg$parse_();
+                      if (s9 !== null) {
+                        peg$reportedPos = s0;
+                        s1 = peg$c205(s1,s4,s8);
+                        if (s1 === null) {
+                          peg$currPos = s0;
+                          s0 = s1;
+                        } else {
+                          s0 = s1;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c1;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$c1;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c1;
+      }
+      if (s0 === null) {
+        s0 = peg$currPos;
+        s1 = peg$parseexpression();
+        if (s1 !== null) {
+          s2 = peg$parse_();
+          if (s2 !== null) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s3 = peg$c15;
+              peg$currPos++;
+            } else {
+              s3 = null;
+              if (peg$silentFails === 0) { peg$fail(peg$c16); }
+            }
+            if (s3 === null) {
+              if (input.substr(peg$currPos, 3) === peg$c206) {
+                s3 = peg$c206;
+                peg$currPos += 3;
+              } else {
+                s3 = null;
+                if (peg$silentFails === 0) { peg$fail(peg$c207); }
+              }
+              if (s3 === null) {
+                if (input.substr(peg$currPos, 2) === peg$c208) {
+                  s3 = peg$c208;
+                  peg$currPos += 2;
+                } else {
+                  s3 = null;
+                  if (peg$silentFails === 0) { peg$fail(peg$c209); }
+                }
+              }
+            }
+            if (s3 !== null) {
+              s4 = peg$parse_();
+              if (s4 !== null) {
+                s5 = peg$parseexpression();
+                if (s5 !== null) {
+                  s6 = peg$parse_();
+                  if (s6 !== null) {
+                    s7 = [];
+                    s8 = peg$currPos;
+                    if (input.charCodeAt(peg$currPos) === 44) {
+                      s9 = peg$c3;
+                      peg$currPos++;
+                    } else {
+                      s9 = null;
+                      if (peg$silentFails === 0) { peg$fail(peg$c4); }
+                    }
+                    if (s9 !== null) {
+                      s10 = peg$parse_();
+                      if (s10 !== null) {
+                        s11 = peg$currPos;
+                        s12 = peg$parseword();
+                        if (s12 !== null) {
+                          s12 = input.substring(s11, peg$currPos);
+                        }
+                        s11 = s12;
+                        if (s11 !== null) {
+                          s12 = peg$parse_();
+                          if (s12 !== null) {
+                            if (input.charCodeAt(peg$currPos) === 58) {
+                              s13 = peg$c15;
+                              peg$currPos++;
+                            } else {
+                              s13 = null;
+                              if (peg$silentFails === 0) { peg$fail(peg$c16); }
+                            }
+                            if (s13 !== null) {
+                              s14 = peg$parse_();
+                              if (s14 !== null) {
+                                s15 = peg$parseexpression();
+                                if (s15 !== null) {
+                                  s16 = peg$parse_();
+                                  if (s16 !== null) {
+                                    s9 = [s9, s10, s11, s12, s13, s14, s15, s16];
+                                    s8 = s9;
+                                  } else {
+                                    peg$currPos = s8;
+                                    s8 = peg$c1;
+                                  }
+                                } else {
+                                  peg$currPos = s8;
+                                  s8 = peg$c1;
+                                }
+                              } else {
+                                peg$currPos = s8;
+                                s8 = peg$c1;
+                              }
+                            } else {
+                              peg$currPos = s8;
+                              s8 = peg$c1;
+                            }
+                          } else {
+                            peg$currPos = s8;
+                            s8 = peg$c1;
+                          }
+                        } else {
+                          peg$currPos = s8;
+                          s8 = peg$c1;
+                        }
+                      } else {
+                        peg$currPos = s8;
+                        s8 = peg$c1;
+                      }
+                    } else {
+                      peg$currPos = s8;
+                      s8 = peg$c1;
+                    }
+                    while (s8 !== null) {
+                      s7.push(s8);
+                      s8 = peg$currPos;
+                      if (input.charCodeAt(peg$currPos) === 44) {
+                        s9 = peg$c3;
+                        peg$currPos++;
+                      } else {
+                        s9 = null;
+                        if (peg$silentFails === 0) { peg$fail(peg$c4); }
+                      }
+                      if (s9 !== null) {
+                        s10 = peg$parse_();
+                        if (s10 !== null) {
+                          s11 = peg$currPos;
+                          s12 = peg$parseword();
+                          if (s12 !== null) {
+                            s12 = input.substring(s11, peg$currPos);
+                          }
+                          s11 = s12;
+                          if (s11 !== null) {
+                            s12 = peg$parse_();
+                            if (s12 !== null) {
+                              if (input.charCodeAt(peg$currPos) === 58) {
+                                s13 = peg$c15;
+                                peg$currPos++;
+                              } else {
+                                s13 = null;
+                                if (peg$silentFails === 0) { peg$fail(peg$c16); }
+                              }
+                              if (s13 !== null) {
+                                s14 = peg$parse_();
+                                if (s14 !== null) {
+                                  s15 = peg$parseexpression();
+                                  if (s15 !== null) {
+                                    s16 = peg$parse_();
+                                    if (s16 !== null) {
+                                      s9 = [s9, s10, s11, s12, s13, s14, s15, s16];
+                                      s8 = s9;
+                                    } else {
+                                      peg$currPos = s8;
+                                      s8 = peg$c1;
+                                    }
+                                  } else {
+                                    peg$currPos = s8;
+                                    s8 = peg$c1;
+                                  }
+                                } else {
+                                  peg$currPos = s8;
+                                  s8 = peg$c1;
+                                }
+                              } else {
+                                peg$currPos = s8;
+                                s8 = peg$c1;
+                              }
+                            } else {
+                              peg$currPos = s8;
+                              s8 = peg$c1;
+                            }
+                          } else {
+                            peg$currPos = s8;
+                            s8 = peg$c1;
+                          }
+                        } else {
+                          peg$currPos = s8;
+                          s8 = peg$c1;
+                        }
+                      } else {
+                        peg$currPos = s8;
+                        s8 = peg$c1;
+                      }
+                    }
+                    if (s7 !== null) {
+                      peg$reportedPos = s0;
+                      s1 = peg$c210(s1,s3,s5,s7);
+                      if (s1 === null) {
+                        peg$currPos = s0;
+                        s0 = s1;
+                      } else {
+                        s0 = s1;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$c1;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$c1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c1;
+        }
+        if (s0 === null) {
+          s0 = peg$currPos;
+          s1 = peg$currPos;
+          s2 = peg$parseword();
+          if (s2 !== null) {
+            s2 = input.substring(s1, peg$currPos);
+          }
+          s1 = s2;
+          if (s1 !== null) {
+            s2 = peg$parse_();
+            if (s2 !== null) {
+              s3 = peg$parseexpression();
+              if (s3 !== null) {
+                s4 = peg$parse_();
+                if (s4 !== null) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c211(s1,s3);
+                  if (s1 === null) {
+                    peg$currPos = s0;
+                    s0 = s1;
+                  } else {
+                    s0 = s1;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c1;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c1;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c1;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c1;
+          }
+        }
+      }
+
+      return s0;
+    }
+
+
+        var BINARY = {
+            "**": "pow",
+            "//": "root",
+            "%%": "log",
+            "*": "mul",
+            "/": "div",
+            "%": "mod",
+            "rem": "rem",
+            "+": "add",
+            "-": "sub",
+            "<": "lt",
+            ">": "gt",
+            "<=": "le",
+            ">=": "ge",
+            "==": "equals",
+            "<=>": "compare",
+            "??": "default",
+            "&&": "and",
+            "||": "or",
+            "<-": "bind",
+            "<->": "bind2",
+            ":": "assign"
+        };
+
+        var UNARY = {
+            "+": "toNumber",
+            "-": "neg",
+            "!": "not",
+            "^": "parent"
+        };
+
+        var BLOCKS = {
+            "map": "mapBlock",
+            "filter": "filterBlock",
+            "some": "someBlock",
+            "every": "everyBlock",
+            "sorted": "sortedBlock",
+            "sortedSet": "sortedSetBlock",
+            "group": "groupBlock",
+            "groupMap": "groupMapBlock",
+            "min": "minBlock",
+            "max": "maxBlock"
+        };
+
+        var STATEMENTS = {
+            ":": "assign",
+            "<-": "bind",
+            "<->": "bind2"
+        };
+
+
+
+    peg$result = peg$startRuleFunction();
+
+    if (peg$result !== null && peg$currPos === input.length) {
+      return peg$result;
+    } else {
+      peg$cleanupExpected(peg$maxFailExpected);
+      peg$reportedPos = Math.max(peg$currPos, peg$maxFailPos);
+
+      throw new SyntaxError(
+        peg$maxFailExpected,
+        peg$reportedPos < input.length ? input.charAt(peg$reportedPos) : null,
+        peg$reportedPos,
+        peg$computePosDetails(peg$reportedPos).line,
+        peg$computePosDetails(peg$reportedPos).column
+      );
+    }
+  }
+
+  return {
+    SyntaxError: SyntaxError,
+    parse      : parse
+  };
+})();
+
+},{}],37:[function(require,module,exports){
+
+var Set = require("collections/set");
+var Dict = require("collections/dict");
+
+var precedence = exports.precedence = Dict();
+var levels = exports.precedenceLevels = [
+    ["tuple", "record"],
+    [
+        "literal",
+        "value",
+        "parameters",
+        "property",
+        "element",
+        "component",
+        "mapBlock",
+        "filterBlock",
+        "sortedBlock",
+        "groupBlock",
+        "groupMapBlock",
+        "with"
+    ],
+    ["not", "neg", "number", "parent"],
+    ["scope"],
+    ["default"],
+    ["pow", "root", "log"],
+    ["mul", "div", "mod", "rem"],
+    ["add", "sub"],
+    ["equals", "lt", "gt", "le", "ge", "compare"],
+    ["and"],
+    ["or"],
+    ["if"]
+];
+
+levels.forEach(function (level) {
+    var predecessors = Set(precedence.keys());
+    level.forEach(function (operator) {
+        precedence.set(operator, predecessors);
+    });
+});
+
+var operatorTokens = exports.operatorTokens = Dict({
+    "**": "pow",
+    "//": "root",
+    "%%": "log",
+    "*": "mul",
+    "/": "div",
+    "%": "mod",
+    "rem": "rem",
+    "+": "add",
+    "-": "sub",
+    "<": "lt",
+    ">": "gt",
+    "<=": "le",
+    ">=": "ge",
+    "==": "equals",
+    "<=>": "compare",
+    "!=": "notEquals",
+    "??": "default",
+    "&&": "and",
+    "||": "or",
+    "?": "then",
+    ":": "else"
+});
+
+exports.operatorTypes = Dict(operatorTokens.map(function (type, token) {
+    return [type, token];
+}));
+
+
+},{"collections/dict":39,"collections/set":53}],38:[function(require,module,exports){
+"use strict";
+
+require("collections/shim");
+
+/*
+ * See: Introduction to Algorithms, Longest Common Subsequence, Algorithms,
+ * Cormen et al, 15.4
+ * This is an adaptation of the LCS and Lehvenstein distance algorithm that
+ * instead of computing the longest subsequence, or the cost of edit, finds the
+ * shortest operational transform.  The cost is the cost of traversal in terms
+ * of "insert" and "delete" operations, where "retain" is free.
+ */
+exports.graphOt = graphOt;
+function graphOt(target, source) {
+    var size = (source.length + 1) * (target.length + 1);
+
+    // edges is a 2D linearized array with a height of target.length + 1 and a
+    // width of source.length + 1.  Each cell corresponds to an operational
+    // transform walking from the top-left to the bottom-right.
+    var edges = Array(size);
+    // we only need to know the costs of the previous source column and the
+    // current source column up to the cell in question.
+    var theseCosts = Array(source.length + 1);
+    var prevCosts = Array(source.length + 1);
+    var tempCosts;
+
+    for (var t = 0; t < target.length + 1; t++) {
+        for (var s = 0; s < source.length + 1; s++) {
+            var direction, cost;
+            if (t === 0 && s === 0) {
+                direction = " ";
+                cost = 0;
+            } else if (t === 0) {
+                direction = "insert";
+                cost = s;
+            } else if (s === 0) {
+                direction = "delete";
+                cost = t;
+            } else if (target[t - 1] === source[s - 1]) {
+                direction = "retain";
+                cost = prevCosts[s - 1];
+            } else {
+                var tCost = theseCosts[s - 1];
+                var sCost = prevCosts[s];
+                // favoring the source tends to produce more removal followed
+                // by insertion, which packs into a swap transforms better
+                if (sCost < tCost) {
+                    direction = "delete";
+                    cost = sCost + 1;
+                } else {
+                    direction = "insert";
+                    cost = tCost + 1;
+                }
+            }
+            edges[t + s * (target.length + 1)] = direction;
+            theseCosts[s] = cost;
+
+        }
+        // swap columns, reuse and overwrite the previous column as the current
+        // column for the next iteration.
+        tempCosts = theseCosts;
+        theseCosts = prevCosts;
+        prevCosts = tempCosts;
+    }
+
+    return {
+        edges: edges,
+        cost: prevCosts[source.length],
+        source: source,
+        target: target
+    };
+}
+
+/**
+ * Tracks backward through a graph produced by graphOt along the cheapest path
+ * from the bottom-right to the top-left to produce the cheapest sequence of
+ * operations.  Accumulates adjacent operations of the same type into a single
+ * operation of greater length.
+ */
+exports.traceOt = traceOt;
+function traceOt(graph) {
+    var ops = [];
+    var edges = graph.edges;
+    var t, tl = t = graph.target.length;
+    var s = graph.source.length;
+    var previous;
+    while (t || s) {
+        var direction = edges[t + s * (tl + 1)];
+        if (direction === "delete") {
+            if (previous && previous[0] === "delete") {
+                previous[1]++;
+            } else {
+                var op = ["delete", 1];
+                previous = op;
+                ops.push(op);
+            }
+            t--;
+        } else if (direction === "insert") {
+            if (previous && previous[0] === "insert") {
+                previous[1]++;
+            } else {
+                var op = ["insert", 1];
+                previous = op;
+                ops.push(op);
+            }
+            s--;
+        } else if (direction === "retain") {
+            var op = ["retain", 1];
+            if (previous && previous[0] === "retain") {
+                previous[1]++;
+            } else {
+                previous = op;
+                ops.push(op);
+            }
+            t--; s--;
+        }
+    }
+    ops.reverse();
+    return ops;
+}
+
+/**
+ * Compute the shortest operational transform on the target sequence to become
+ * the source sequence.
+ */
+exports.ot = ot;
+function ot(target, source) {
+    return traceOt(graphOt(target, source));
+}
+
+/**
+ * Compute the shortest sequence of splice or swap operations on the target
+ * sequence to become the source sequence.
+ */
+exports.diff = diff;
+function diff(target, source) {
+    var ops = ot(target, source);
+    var swops = [];
+
+    // convert ops to splice/swap operations
+    var t = 0;
+    var s = 0;
+    var o = 0;
+    var previous;
+    while (o < ops.length) {
+        var op = ops[o++];
+        if (op[0] === "insert") {
+            swops.push([s, 0, source.slice(s, s + op[1])]);
+            s += op[1];
+        } else if (op[0] === "delete") {
+            if (o < ops.length && ops[o][0] === "insert") {
+                var insert = ops[o++];
+                swops.push([s, op[1], source.slice(s, s + insert[1])]);
+                t += op[1];
+                s += insert[1];
+            } else {
+                swops.push([s, op[1]]);
+                t += op[1];
+            }
+        } else if (op[0] == "retain") {
+            t += op[1];
+            s += op[1];
+        }
+    }
+
+    return swops;
+}
+
+/**
+ * Apply the given sequence of swap operations on the target sequence.
+ */
+exports.apply = apply;
+function apply(target, patch) {
+    for (var s = 0; s < patch.length; s++) {
+        target.swap.apply(target, patch[s]);
+    }
+}
+
+/**
+ * Apply the shortest sequence of swap operations on the target sequence for it
+ * to become equivalent to the target sequence.
+ */
+exports.merge = merge;
+function merge(target, source) {
+    apply(target, diff(target, source));
+}
+
+
+},{"collections/shim":58}],39:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+// Burgled from https://github.com/domenic/dict
+
+module.exports = Dict;
+function Dict(values, getDefault) {
+    if (!(this instanceof Dict)) {
+        return new Dict(values, getDefault);
+    }
+    getDefault = getDefault || Function.noop;
+    this.getDefault = getDefault;
+    this.store = {};
+    this.length = 0;
+    this.addEach(values);
+}
+
+Dict.Dict = Dict; // hack so require("dict").Dict will work in MontageJS.
+
+function mangle(key) {
+    return "~" + key;
+}
+
+function unmangle(mangled) {
+    return mangled.slice(1);
+}
+
+Object.addEach(Dict.prototype, GenericCollection.prototype);
+Object.addEach(Dict.prototype, GenericMap.prototype);
+Object.addEach(Dict.prototype, PropertyChanges.prototype);
+
+Dict.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.mangle, this.getDefault);
+};
+
+Dict.prototype.assertString = function (key) {
+    if (typeof key !== "string") {
+        throw new TypeError("key must be a string but Got " + key);
+    }
+}
+
+Dict.prototype.get = function (key, defaultValue) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) {
+        return this.store[mangled];
+    } else if (arguments.length > 1) {
+        return defaultValue;
+    } else {
+        return this.getDefault(key);
+    }
+};
+
+Dict.prototype.set = function (key, value) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) { // update
+        if (this.dispatchesBeforeMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        this.store[mangled] = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return false;
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        this.length++;
+        this.store[mangled] = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return true;
+    }
+};
+
+Dict.prototype.has = function (key) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    return mangled in this.store;
+};
+
+Dict.prototype["delete"] = function (key) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) {
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        delete this.store[mangle(key)];
+        this.length--;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+        return true;
+    }
+    return false;
+};
+
+Dict.prototype.clear = function () {
+    var key, mangled;
+    for (mangled in this.store) {
+        key = unmangle(mangled);
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        delete this.store[mangled];
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+    }
+    this.length = 0;
+};
+
+Dict.prototype.reduce = function (callback, basis, thisp) {
+    for (var mangled in this.store) {
+        basis = callback.call(thisp, basis, this.store[mangled], unmangle(mangled), this);
+    }
+    return basis;
+};
+
+Dict.prototype.reduceRight = function (callback, basis, thisp) {
+    var self = this;
+    var store = this.store;
+    return Object.keys(this.store).reduceRight(function (basis, mangled) {
+        return callback.call(thisp, basis, store[mangled], unmangle(mangled), self);
+    }, basis);
+};
+
+Dict.prototype.one = function () {
+    var key;
+    for (key in this.store) {
+        return this.store[key];
+    }
+};
+
+
+},{"./generic-collection":41,"./generic-map":42,"./listen/property-changes":49,"./shim":58}],40:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var Dict = require("./dict");
+var List = require("./list");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var TreeLog = require("./tree-log");
+var PropertyChanges = require("./listen/property-changes");
+
+var object_has = Object.prototype.hasOwnProperty;
+
+module.exports = FastSet;
+
+function FastSet(values, equals, hash, getDefault) {
+    if (!(this instanceof FastSet)) {
+        return new FastSet(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    this.buckets = new this.Buckets(null, this.Bucket);
+    this.length = 0;
+    this.addEach(values);
+}
+
+FastSet.FastSet = FastSet; // hack so require("fast-set").FastSet will work in MontageJS
+
+Object.addEach(FastSet.prototype, GenericCollection.prototype);
+Object.addEach(FastSet.prototype, GenericSet.prototype);
+Object.addEach(FastSet.prototype, PropertyChanges.prototype);
+
+FastSet.prototype.Buckets = Dict;
+FastSet.prototype.Bucket = List;
+
+FastSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+FastSet.prototype.has = function (value) {
+    var hash = this.contentHash(value);
+    return this.buckets.get(hash).has(value);
+};
+
+FastSet.prototype.get = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        return buckets.get(hash).get(value);
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+FastSet.prototype['delete'] = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        var bucket = buckets.get(hash);
+        if (bucket["delete"](value)) {
+            this.length--;
+            if (bucket.length === 0) {
+                buckets["delete"](hash);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+FastSet.prototype.clear = function () {
+    this.buckets.clear();
+    this.length = 0;
+};
+
+FastSet.prototype.add = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (!buckets.has(hash)) {
+        buckets.set(hash, new this.Bucket(null, this.contentEquals));
+    }
+    if (!buckets.get(hash).has(value)) {
+        buckets.get(hash).add(value);
+        this.length++;
+        return true;
+    }
+    return false;
+};
+
+FastSet.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var buckets = this.buckets;
+    var index = 0;
+    return buckets.reduce(function (basis, bucket) {
+        return bucket.reduce(function (basis, value) {
+            return callback.call(thisp, basis, value, index++, this);
+        }, basis, this);
+    }, basis, this);
+};
+
+FastSet.prototype.one = function () {
+    if (this.length > 0) {
+        return this.buckets.one().one();
+    }
+};
+
+FastSet.prototype.iterate = function () {
+    return this.buckets.values().flatten().iterate();
+};
+
+FastSet.prototype.log = function (charmap, logNode, callback, thisp) {
+    charmap = charmap || TreeLog.unicodeSharp;
+    logNode = logNode || this.logNode;
+    if (!callback) {
+        callback = console.log;
+        thisp = console;
+    }
+    callback = callback.bind(thisp);
+
+    var buckets = this.buckets;
+    var hashes = buckets.keys();
+    hashes.forEach(function (hash, index) {
+        var branch;
+        var leader;
+        if (index === hashes.length - 1) {
+            branch = charmap.fromAbove;
+            leader = ' ';
+        } else if (index === 0) {
+            branch = charmap.branchDown;
+            leader = charmap.strafe;
+        } else {
+            branch = charmap.fromBoth;
+            leader = charmap.strafe;
+        }
+        var bucket = buckets.get(hash);
+        callback.call(thisp, branch + charmap.through + charmap.branchDown + ' ' + hash);
+        bucket.forEach(function (value, node) {
+            var branch, below;
+            if (node === bucket.head.prev) {
+                branch = charmap.fromAbove;
+                below = ' ';
+            } else {
+                branch = charmap.fromBoth;
+                below = charmap.strafe;
+            }
+            var written;
+            logNode(
+                node,
+                function (line) {
+                    if (!written) {
+                        callback.call(thisp, leader + ' ' + branch + charmap.through + charmap.through + line);
+                        written = true;
+                    } else {
+                        callback.call(thisp, leader + ' ' + below + '  ' + line);
+                    }
+                },
+                function (line) {
+                    callback.call(thisp, leader + ' ' + charmap.strafe + '  ' + line);
+                }
+            );
+        });
+    });
+};
+
+FastSet.prototype.logNode = function (node, write) {
+    var value = node.value;
+    if (Object(value) === value) {
+        JSON.stringify(value, null, 4).split("\n").forEach(function (line) {
+            write(" " + line);
+        });
+    } else {
+        write(" " + value);
+    }
+};
+
+
+},{"./dict":39,"./generic-collection":41,"./generic-set":44,"./list":46,"./listen/property-changes":49,"./shim":58,"./tree-log":61}],41:[function(require,module,exports){
+"use strict";
+
+module.exports = GenericCollection;
+function GenericCollection() {
+    throw new Error("Can't construct. GenericCollection is a mixin.");
+}
+
+GenericCollection.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            values.forEach(this.add, this);
+        } else if (typeof values.length === "number") {
+            // Array-like objects that do not implement forEach, ergo,
+            // Arguments
+            for (var i = 0; i < values.length; i++) {
+                this.add(values[i], i);
+            }
+        } else {
+            Object.keys(values).forEach(function (key) {
+                this.add(values[key], key);
+            }, this);
+        }
+    }
+    return this;
+};
+
+// This is sufficiently generic for Map (since the value may be a key)
+// and ordered collections (since it forwards the equals argument)
+GenericCollection.prototype.deleteEach = function (values, equals) {
+    values.forEach(function (value) {
+        this["delete"](value, equals);
+    }, this);
+    return this;
+};
+
+// all of the following functions are implemented in terms of "reduce".
+// some need "constructClone".
+
+GenericCollection.prototype.forEach = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (undefined, value, key, object, depth) {
+        callback.call(thisp, value, key, object, depth);
+    }, undefined);
+};
+
+GenericCollection.prototype.map = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = [];
+    this.reduce(function (undefined, value, key, object, depth) {
+        result.push(callback.call(thisp, value, key, object, depth));
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.enumerate = function (start) {
+    if (start == null) {
+        start = 0;
+    }
+    var result = [];
+    this.reduce(function (undefined, value) {
+        result.push([start++, value]);
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.group = function (callback, thisp, equals) {
+    equals = equals || Object.equals;
+    var groups = [];
+    var keys = [];
+    this.forEach(function (value, key, object) {
+        var key = callback.call(thisp, value, key, object);
+        var index = keys.indexOf(key, equals);
+        var group;
+        if (index === -1) {
+            group = [];
+            groups.push([key, group]);
+            keys.push(key);
+        } else {
+            group = groups[index][1];
+        }
+        group.push(value);
+    });
+    return groups;
+};
+
+GenericCollection.prototype.toArray = function () {
+    return this.map(Function.identity);
+};
+
+// this depends on stringable keys, which apply to Array and Iterator
+// because they have numeric keys and all Maps since they may use
+// strings as keys.  List, Set, and SortedSet have nodes for keys, so
+// toObject would not be meaningful.
+GenericCollection.prototype.toObject = function () {
+    var object = {};
+    this.reduce(function (undefined, value, key) {
+        object[key] = value;
+    }, undefined);
+    return object;
+};
+
+GenericCollection.prototype.filter = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = this.constructClone();
+    this.reduce(function (undefined, value, key, object, depth) {
+        if (callback.call(thisp, value, key, object, depth)) {
+            result.add(value);
+        }
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.every = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result && callback.call(thisp, value, key, object, depth);
+    }, true);
+};
+
+GenericCollection.prototype.some = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result || callback.call(thisp, value, key, object, depth);
+    }, false);
+};
+
+GenericCollection.prototype.all = function () {
+    return this.every(Boolean);
+};
+
+GenericCollection.prototype.any = function () {
+    return this.some(Boolean);
+};
+
+GenericCollection.prototype.min = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) < 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.max = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) > 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.sum = function (zero) {
+    zero = zero === undefined ? 0 : zero;
+    return this.reduce(function (a, b) {
+        return a + b;
+    }, zero);
+};
+
+GenericCollection.prototype.average = function (zero) {
+    var sum = zero === undefined ? 0 : zero;
+    var count = zero === undefined ? 0 : zero;
+    this.reduce(function (undefined, value) {
+        sum += value;
+        count += 1;
+    }, undefined);
+    return sum / count;
+};
+
+GenericCollection.prototype.concat = function () {
+    var result = this.constructClone(this);
+    for (var i = 0; i < arguments.length; i++) {
+        result.addEach(arguments[i]);
+    }
+    return result;
+};
+
+GenericCollection.prototype.flatten = function () {
+    var self = this;
+    return this.reduce(function (result, array) {
+        array.forEach(function (value) {
+            this.push(value);
+        }, result, self);
+        return result;
+    }, []);
+};
+
+GenericCollection.prototype.zip = function () {
+    var table = Array.prototype.slice.call(arguments);
+    table.unshift(this);
+    return Array.unzip(table);
+}
+
+GenericCollection.prototype.join = function (delimiter) {
+    return this.reduce(function (result, string) {
+        return result + delimiter + string;
+    });
+};
+
+GenericCollection.prototype.sorted = function (compare, by, order) {
+    compare = compare || this.contentCompare || Object.compare;
+    // account for comparators generated by Function.by
+    if (compare.by) {
+        by = compare.by;
+        compare = compare.compare || this.contentCompare || Object.compare;
+    } else {
+        by = by || Function.identity;
+    }
+    if (order === undefined)
+        order = 1;
+    return this.map(function (item) {
+        return {
+            by: by(item),
+            value: item
+        };
+    })
+    .sort(function (a, b) {
+        return compare(a.by, b.by) * order;
+    })
+    .map(function (pair) {
+        return pair.value;
+    });
+};
+
+GenericCollection.prototype.reversed = function () {
+    return this.constructClone(this).reverse();
+};
+
+GenericCollection.prototype.clone = function (depth, memo) {
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return this;
+    }
+    var clone = this.constructClone();
+    this.forEach(function (value, key) {
+        clone.add(Object.clone(value, depth - 1, memo), key);
+    }, this);
+    return clone;
+};
+
+GenericCollection.prototype.only = function () {
+    if (this.length === 1) {
+        return this.one();
+    }
+};
+
+GenericCollection.prototype.iterator = function () {
+    return this.iterate.apply(this, arguments);
+};
+
+require("./shim-array");
+
+
+},{"./shim-array":54}],42:[function(require,module,exports){
+"use strict";
+
+var Object = require("./shim-object");
+var MapChanges = require("./listen/map-changes");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = GenericMap;
+function GenericMap() {
+    throw new Error("Can't construct. GenericMap is a mixin.");
+}
+
+Object.addEach(GenericMap.prototype, MapChanges.prototype);
+Object.addEach(GenericMap.prototype, PropertyChanges.prototype);
+
+// all of these methods depend on the constructor providing a `store` set
+
+GenericMap.prototype.isMap = true;
+
+GenericMap.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            // copy map-alikes
+            if (values.isMap === true) {
+                values.forEach(function (value, key) {
+                    this.set(key, value);
+                }, this);
+            // iterate key value pairs of other iterables
+            } else {
+                values.forEach(function (pair) {
+                    this.set(pair[0], pair[1]);
+                }, this);
+            }
+        } else {
+            // copy other objects as map-alikes
+            Object.keys(values).forEach(function (key) {
+                this.set(key, values[key]);
+            }, this);
+        }
+    }
+    return this;
+}
+
+GenericMap.prototype.get = function (key, defaultValue) {
+    var item = this.store.get(new this.Item(key));
+    if (item) {
+        return item.value;
+    } else if (arguments.length > 1) {
+        return defaultValue;
+    } else {
+        return this.getDefault(key);
+    }
+};
+
+GenericMap.prototype.set = function (key, value) {
+    var item = new this.Item(key, value);
+    var found = this.store.get(item);
+    var grew = false;
+    if (found) { // update
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, found.value);
+        }
+        found.value = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        if (this.store.add(item)) {
+            this.length++;
+            grew = true;
+        }
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    }
+    return grew;
+};
+
+GenericMap.prototype.add = function (value, key) {
+    return this.set(key, value);
+};
+
+GenericMap.prototype.has = function (key) {
+    return this.store.has(new this.Item(key));
+};
+
+GenericMap.prototype['delete'] = function (key) {
+    var item = new this.Item(key);
+    if (this.store.has(item)) {
+        var from = this.store.get(item).value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, from);
+        }
+        this.store["delete"](item);
+        this.length--;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+        return true;
+    }
+    return false;
+};
+
+GenericMap.prototype.clear = function () {
+    var keys;
+    if (this.dispatchesMapChanges) {
+        this.forEach(function (value, key) {
+            this.dispatchBeforeMapChange(key, value);
+        }, this);
+        keys = this.keys();
+    }
+    this.store.clear();
+    this.length = 0;
+    if (this.dispatchesMapChanges) {
+        keys.forEach(function (key) {
+            this.dispatchMapChange(key);
+        }, this);
+    }
+};
+
+GenericMap.prototype.reduce = function (callback, basis, thisp) {
+    return this.store.reduce(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.reduceRight = function (callback, basis, thisp) {
+    return this.store.reduceRight(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.keys = function () {
+    return this.map(function (value, key) {
+        return key;
+    });
+};
+
+GenericMap.prototype.values = function () {
+    return this.map(Function.identity);
+};
+
+GenericMap.prototype.entries = function () {
+    return this.map(function (value, key) {
+        return [key, value];
+    });
+};
+
+// XXX deprecated
+GenericMap.prototype.items = function () {
+    return this.entries();
+};
+
+GenericMap.prototype.equals = function (that, equals) {
+    equals = equals || Object.equals;
+    if (this === that) {
+        return true;
+    } else if (Object.can(that, "every")) {
+        return that.length === this.length && that.every(function (value, key) {
+            return equals(this.get(key), value);
+        }, this);
+    } else {
+        var keys = Object.keys(that);
+        return keys.length === this.length && Object.keys(that).every(function (key) {
+            return equals(this.get(key), that[key]);
+        }, this);
+    }
+};
+
+GenericMap.prototype.Item = Item;
+
+function Item(key, value) {
+    this.key = key;
+    this.value = value;
+}
+
+Item.prototype.equals = function (that) {
+    return Object.equals(this.key, that.key) && Object.equals(this.value, that.value);
+};
+
+Item.prototype.compare = function (that) {
+    return Object.compare(this.key, that.key);
+};
+
+
+},{"./listen/map-changes":48,"./listen/property-changes":49,"./shim-object":56}],43:[function(require,module,exports){
+
+var Object = require("./shim-object");
+
+module.exports = GenericOrder;
+function GenericOrder() {
+    throw new Error("Can't construct. GenericOrder is a mixin.");
+}
+
+GenericOrder.prototype.equals = function (that, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+
+    if (this === that) {
+        return true;
+    }
+    if (!that) {
+        return false;
+    }
+
+    var self = this;
+    return (
+        this.length === that.length &&
+        this.zip(that).every(function (pair) {
+            return equals(pair[0], pair[1]);
+        })
+    );
+};
+
+GenericOrder.prototype.compare = function (that, compare) {
+    compare = compare || this.contentCompare || Object.compare;
+
+    if (this === that) {
+        return 0;
+    }
+    if (!that) {
+        return 1;
+    }
+
+    var length = Math.min(this.length, that.length);
+    var comparison = this.zip(that).reduce(function (comparison, pair, index) {
+        if (comparison === 0) {
+            if (index >= length) {
+                return comparison;
+            } else {
+                return compare(pair[0], pair[1]);
+            }
+        } else {
+            return comparison;
+        }
+    }, 0);
+    if (comparison === 0) {
+        return this.length - that.length;
+    }
+    return comparison;
+};
+
+
+},{"./shim-object":56}],44:[function(require,module,exports){
+
+module.exports = GenericSet;
+function GenericSet() {
+    throw new Error("Can't construct. GenericSet is a mixin.");
+}
+
+GenericSet.prototype.union = function (that) {
+    var union =  this.constructClone(this);
+    union.addEach(that);
+    return union;
+};
+
+GenericSet.prototype.intersection = function (that) {
+    return this.constructClone(this.filter(function (value) {
+        return that.has(value);
+    }));
+};
+
+GenericSet.prototype.difference = function (that) {
+    var union =  this.constructClone(this);
+    union.deleteEach(that);
+    return union;
+};
+
+GenericSet.prototype.symmetricDifference = function (that) {
+    var union = this.union(that);
+    var intersection = this.intersection(that);
+    return union.difference(intersection);
+};
+
+GenericSet.prototype.equals = function (that, equals) {
+    var self = this;
+    return (
+        Object.can(that, "reduce") &&
+        this.length === that.length &&
+        that.reduce(function (equal, value) {
+            return equal && self.has(value, equals);
+        }, true)
+    );
+};
+
+// W3C DOMTokenList API overlap (does not handle variadic arguments)
+
+GenericSet.prototype.contains = function (value) {
+    return this.has(value);
+};
+
+GenericSet.prototype.remove = function (value) {
+    return this["delete"](value);
+};
+
+GenericSet.prototype.toggle = function (value) {
+    if (this.has(value)) {
+        this["delete"](value);
+    } else {
+        this.add(value);
+    }
+};
+
+
+},{}],45:[function(require,module,exports){
+
+// Adapted from Eloquent JavaScript by Marijn Haverbeke
+// http://eloquentjavascript.net/appendix2.html
+
+var ArrayChanges = require("./listen/array-changes");
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var MapChanges = require("./listen/map-changes");
+var RangeChanges = require("./listen/range-changes");
+var PropertyChanges = require("./listen/property-changes");
+
+// Max Heap by default.  Comparison can be reversed to produce a Min Heap.
+
+module.exports = Heap;
+
+function Heap(values, equals, compare) {
+    if (!(this instanceof Heap)) {
+        return new Heap(values, equals, compare);
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.content = [];
+    this.length = 0;
+    this.addEach(values);
+}
+
+Heap.Heap = Heap; // hack so require("heap").Heap will work in MontageJS
+
+Object.addEach(Heap.prototype, GenericCollection.prototype);
+Object.addEach(Heap.prototype, PropertyChanges.prototype);
+Object.addEach(Heap.prototype, RangeChanges.prototype);
+Object.addEach(Heap.prototype, MapChanges.prototype);
+
+Heap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare
+    );
+};
+
+Heap.prototype.push = function (value) {
+    this.content.push(value);
+    this.float(this.content.length - 1);
+    this.length++;
+};
+
+Heap.prototype.pop = function () {
+    // Store the first value so we can return it later.  This will leave a gap
+    // at index 0 that must be filled.
+    var result = this.content[0];
+    // Remove the value at the end of the array.  The value most be removed
+    // from the end to preserve the completness of the tree, despite that the
+    // last child is also among the most likely to need to sink back to the
+    // bottom.
+    var top = this.content.pop();
+    // If there are any values remaining, put the last value on the top and
+    // let it sink back down.
+    if (this.content.length > 0) {
+        this.content.set(0, top);
+        this.sink(0);
+    }
+    this.length--;
+    return result;
+};
+
+Heap.prototype.add = function (value) {
+    this.push(value);
+};
+
+// indexOf must do a linear search since a binary heap does not preserve a
+// strict sort order.  Thus, deletion takes linear time for all values except
+// for the max value.
+
+Heap.prototype.indexOf = function (value) {
+    for (var index = 0; index < this.length; index++) {
+        if (this.contentEquals(this.content[index], value)) {
+            return index;
+        }
+    }
+    return -1;
+};
+
+Heap.prototype.delete = function (value) {
+    var index = this.indexOf(value);
+    if (index === -1)
+        return false;
+    var top = this.content.pop();
+    if (index === this.content.length)
+        return true;
+    this.content.set(index, top);
+    var comparison = this.contentCompare(top, value);
+    if (comparison > 0) {
+        this.float(index);
+    } else if (comparison < 0) {
+        this.sink(index);
+    }
+    this.length--;
+    return true;
+};
+
+Heap.prototype.peek = function () {
+    if (this.length) {
+        return this.content[0];
+    }
+};
+
+Heap.prototype.max = function () {
+    return this.peek();
+};
+
+Heap.prototype.one = function () {
+    return this.peek();
+};
+
+// Brings a value up until its parent is greater than it
+Heap.prototype.float = function (index) {
+    // Grab the value that is being adjusted
+    var value = this.content[index];
+    // A value can go no higher that the top: index 0
+    while (index > 0) {
+        // Compute the parent value's index and fetch it
+        var parentIndex = Math.floor((index + 1) / 2) - 1;
+        var parent = this.content[parentIndex];
+        // If the parent is less than it
+        if (this.contentCompare(parent, value) < 0) {
+            this.content.set(parentIndex, value);
+            this.content.set(index, parent);
+        } else {
+            // Stop propagating if the parent is greater than the value.
+            break;
+        }
+        // Proceed upward
+        index = parentIndex;
+    }
+};
+
+// Brings a value down until its children are both less than it
+Heap.prototype.sink = function (index) {
+    // Moves a value downward until it is greater than its children.
+    var length = this.content.length;
+    var value = this.content[index];
+    var left, right, leftIndex, rightIndex, swapIndex, needsSwap;
+
+    while (true) {
+        // Invariant: the value is at index.
+        // Variant: the index proceedes down the tree.
+
+        // Compute the indicies of the children.
+        rightIndex = (index + 1) * 2;
+        leftIndex = rightIndex - 1;
+
+        // If the left child exists, determine whether it is greater than the
+        // parent (value) and thus whether it can be floated upward.
+        needsSwap = false;
+        if (leftIndex < length) {
+            // Look it up and compare it.
+            var left = this.content[leftIndex];
+            var comparison = this.contentCompare(left, value);
+            // If the child is greater than the parent, it can be floated.
+            if (comparison > 0) {
+                swapIndex = leftIndex;
+                needsSwap = true;
+            }
+        }
+
+        // If the right child exists, determine whether it is greater than the
+        // parent (value), or even greater than the left child.
+        if (rightIndex < length) {
+            var right = this.content[rightIndex];
+            var comparison = this.contentCompare(right, needsSwap ? left : value);
+            if (comparison > 0) {
+                swapIndex = rightIndex;
+                needsSwap = true;
+            }
+        }
+
+        // if there is a child that is less than the value, float the child and
+        // sink the value.
+        if (needsSwap) {
+            this.content.set(index, this.content[swapIndex]);
+            this.content.set(swapIndex, value);
+            index = swapIndex;
+            // and continue sinking
+        } else {
+            // if the children are both less than the value
+            break;
+        }
+
+    }
+
+};
+
+Heap.prototype.clear = function () {
+    this.content.clear();
+    this.length = 0;
+};
+
+Heap.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.content.reduce(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+Heap.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.content.reduceRight(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+Heap.prototype.makeObservable = function () {
+    // TODO refactor dispatchers to allow direct forwarding
+    this.content.addRangeChangeListener(this, "content");
+    this.content.addBeforeRangeChangeListener(this, "content");
+    this.content.addMapChangeListener(this, "content");
+    this.content.addBeforeMapChangeListener(this, "content");
+};
+
+Heap.prototype.handleContentRangeChange = function (plus, minus, index) {
+    this.dispatchRangeChange(plus, minus, index);
+};
+
+Heap.prototype.handleContentRangeWillChange = function (plus, minus, index) {
+    this.dispatchBeforeRangeChange(plus, minus, index);
+};
+
+Heap.prototype.handleContentMapChange = function (value, key) {
+    this.dispatchMapChange(key, value);
+};
+
+Heap.prototype.handleContentMapWillChange = function (value, key) {
+    this.dispatchBeforeMapChange(key, value);
+};
+
+
+},{"./generic-collection":41,"./listen/array-changes":47,"./listen/map-changes":48,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],46:[function(require,module,exports){
+"use strict";
+
+module.exports = List;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericOrder = require("./generic-order");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+function List(values, equals, getDefault) {
+    if (!(this instanceof List)) {
+        return new List(values, equals, getDefault);
+    }
+    var head = this.head = new this.Node();
+    head.next = head;
+    head.prev = head;
+    this.contentEquals = equals || Object.equals;
+    this.getDefault = getDefault || Function.noop;
+    this.length = 0;
+    this.addEach(values);
+}
+
+List.List = List; // hack so require("list").List will work in MontageJS
+
+Object.addEach(List.prototype, GenericCollection.prototype);
+Object.addEach(List.prototype, GenericOrder.prototype);
+Object.addEach(List.prototype, PropertyChanges.prototype);
+Object.addEach(List.prototype, RangeChanges.prototype);
+
+List.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.contentEquals, this.getDefault);
+};
+
+List.prototype.find = function (value, equals) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = head.next;
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.next;
+    }
+};
+
+List.prototype.findLast = function (value, equals) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = head.prev;
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.prev;
+    }
+};
+
+List.prototype.has = function (value, equals) {
+    return !!this.find(value, equals);
+};
+
+List.prototype.get = function (value, equals) {
+    var found = this.find(value, equals);
+    if (found) {
+        return found.value;
+    }
+    return this.getDefault(value);
+};
+
+// LIFO (delete removes the most recently added equivalent value)
+List.prototype['delete'] = function (value, equals) {
+    var found = this.findLast(value, equals);
+    if (found) {
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, found.index);
+        }
+        found['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(found.next, found.index);
+            this.dispatchRangeChange(plus, minus, found.index);
+        }
+        return true;
+    }
+    return false;
+};
+
+List.prototype.clear = function () {
+    var plus, minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.toArray();
+        plus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    this.head.next = this.head.prev = this.head;
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.add = function (value) {
+    var node = new this.Node(value)
+    if (this.dispatchesRangeChanges) {
+        node.index = this.length;
+        this.dispatchBeforeRangeChange([value], [], node.index);
+    }
+    this.head.addBefore(node);
+    this.length++;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([value], [], node.index);
+    }
+    return true;
+};
+
+List.prototype.push = function () {
+    var head = this.head;
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = []
+        var index = this.length;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+        var start = this.head.prev;
+    }
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        head.addBefore(node);
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(start.next, start.index === undefined ? 0 : start.index + 1);
+        this.dispatchRangeChange(plus, minus, index);
+    }
+};
+
+List.prototype.unshift = function () {
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        at.addAfter(node);
+        at = node;
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(this.head.next, 0);
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.pop = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.prev.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            var index = this.length - 1;
+            this.dispatchBeforeRangeChange(plus, minus, index);
+        }
+        head.prev['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange(plus, minus, index);
+        }
+    }
+    return value;
+};
+
+List.prototype.shift = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.next.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, 0);
+        }
+        head.next['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(this.head.next, 0);
+            this.dispatchRangeChange(plus, minus, 0);
+        }
+    }
+    return value;
+};
+
+List.prototype.peek = function () {
+    if (this.head !== this.head.next) {
+        return this.head.next.value;
+    }
+};
+
+List.prototype.poke = function (value) {
+    if (this.head !== this.head.next) {
+        this.head.next.value = value;
+    } else {
+        this.push(value);
+    }
+};
+
+List.prototype.one = function () {
+    return this.peek();
+};
+
+// an internal utility for coercing index offsets to nodes
+List.prototype.scan = function (at, fallback) {
+    var head = this.head;
+    if (typeof at === "number") {
+        var count = at;
+        if (count >= 0) {
+            at = head.next;
+            while (count) {
+                count--;
+                at = at.next;
+                if (at == head) {
+                    break;
+                }
+            }
+        } else {
+            at = head;
+            while (count < 0) {
+                count++;
+                at = at.prev;
+                if (at == head) {
+                    break;
+                }
+            }
+        }
+        return at;
+    } else {
+        return at || fallback;
+    }
+};
+
+// at and end may both be positive or negative numbers (in which cases they
+// correspond to numeric indicies, or nodes)
+List.prototype.slice = function (at, end) {
+    var sliced = [];
+    var head = this.head;
+    at = this.scan(at, head.next);
+    end = this.scan(end, head);
+
+    while (at !== end && at !== head) {
+        sliced.push(at.value);
+        at = at.next;
+    }
+
+    return sliced;
+};
+
+List.prototype.splice = function (at, length /*...plus*/) {
+    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
+};
+
+List.prototype.swap = function (start, length, plus) {
+    var initial = start;
+    // start will be head if start is null or -1 (meaning from the end), but
+    // will be head.next if start is 0 (meaning from the beginning)
+    start = this.scan(start, this.head);
+    if (length == null) {
+        length = Infinity;
+    }
+    plus = Array.from(plus);
+
+    // collect the minus array
+    var minus = [];
+    var at = start;
+    while (length-- && length >= 0 && at !== this.head) {
+        minus.push(at.value);
+        at = at.next;
+    }
+
+    // before range change
+    var index, startNode;
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            index = this.length;
+        } else if (start.prev === this.head) {
+            index = 0;
+        } else {
+            index = start.index;
+        }
+        startNode = start.prev;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+    }
+
+    // delete minus
+    var at = start;
+    for (var i = 0, at = start; i < minus.length; i++, at = at.next) {
+        at["delete"]();
+    }
+    // add plus
+    if (initial == null && at === this.head) {
+        at = this.head.next;
+    }
+    for (var i = 0; i < plus.length; i++) {
+        var node = new this.Node(plus[i]);
+        at.addBefore(node);
+    }
+    // adjust length
+    this.length += plus.length - minus.length;
+
+    // after range change
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            this.updateIndexes(this.head.next, 0);
+        } else {
+            this.updateIndexes(startNode.next, startNode.index + 1);
+        }
+        this.dispatchRangeChange(plus, minus, index);
+    }
+
+    return minus;
+};
+
+List.prototype.reverse = function () {
+    if (this.dispatchesRangeChanges) {
+        var minus = this.toArray();
+        var plus = minus.reversed();
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    do {
+        var temp = at.next;
+        at.next = at.prev;
+        at.prev = temp;
+        at = at.next;
+    } while (at !== this.head);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+    return this;
+};
+
+List.prototype.sort = function () {
+    this.swap(0, this.length, this.sorted());
+};
+
+// TODO account for missing basis argument
+List.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.next;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.next;
+    }
+    return basis;
+};
+
+List.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.prev;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.prev;
+    }
+    return basis;
+};
+
+List.prototype.updateIndexes = function (node, index) {
+    while (node !== this.head) {
+        node.index = index++;
+        node = node.next;
+    }
+};
+
+List.prototype.makeObservable = function () {
+    this.head.index = -1;
+    this.updateIndexes(this.head.next, 0);
+    this.dispatchesRangeChanges = true;
+};
+
+List.prototype.iterate = function () {
+    return new ListIterator(this.head);
+};
+
+function ListIterator(head) {
+    this.head = head;
+    this.at = head.next;
+};
+
+ListIterator.prototype.next = function () {
+    if (this.at === this.head) {
+        throw StopIteration;
+    } else {
+        var value = this.at.value;
+        this.at = this.at.next;
+        return value;
+    }
+};
+
+List.prototype.Node = Node;
+
+function Node(value) {
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+};
+
+Node.prototype['delete'] = function () {
+    this.prev.next = this.next;
+    this.next.prev = this.prev;
+};
+
+Node.prototype.addBefore = function (node) {
+    var prev = this.prev;
+    this.prev = node;
+    node.prev = prev;
+    prev.next = node;
+    node.next = this;
+};
+
+Node.prototype.addAfter = function (node) {
+    var next = this.next;
+    this.next = node;
+    node.next = next;
+    next.prev = node;
+    node.prev = this;
+};
+
+
+},{"./generic-collection":41,"./generic-order":43,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],47:[function(require,module,exports){
+/*
+    Based in part on observable arrays from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/*
+    This module is responsible for observing changes to owned properties of
+    objects and changes to the content of arrays caused by method calls.
+    The interface for observing array content changes establishes the methods
+    necessary for any collection with observable content.
+*/
+
+require("../shim");
+var List = require("../list");
+var WeakMap = require("weak-map");
+var PropertyChanges = require("./property-changes");
+var RangeChanges = require("./range-changes");
+var MapChanges = require("./map-changes");
+
+var array_splice = Array.prototype.splice;
+var array_slice = Array.prototype.slice;
+var array_reverse = Array.prototype.reverse;
+var array_sort = Array.prototype.sort;
+
+// use different strategies for making arrays observable between Internet
+// Explorer and other browsers.
+var protoIsSupported = {}.__proto__ === Object.prototype;
+var array_makeObservable;
+if (protoIsSupported) {
+    array_makeObservable = function () {
+        this.__proto__ = ChangeDispatchArray;
+    };
+} else {
+    array_makeObservable = function () {
+        Object.defineProperties(this, observableArrayProperties);
+    };
+}
+
+Object.defineProperty(Array.prototype, "makeObservable", {
+    value: array_makeObservable,
+    writable: true,
+    configurable: true,
+    enumerable: false
+});
+
+function defineEach(prototype) {
+    for (var name in prototype) {
+        Object.defineProperty(Array.prototype, name, {
+            value: prototype[name],
+            writable: true,
+            configurable: true,
+            enumerable: false
+        });
+    }
+}
+
+defineEach(PropertyChanges.prototype);
+defineEach(RangeChanges.prototype);
+defineEach(MapChanges.prototype);
+
+var observableArrayProperties = {
+
+    isObservable: {
+        value: true,
+        writable: true,
+        configurable: true
+    },
+
+    makeObservable: {
+        value: Function.noop, // idempotent
+        writable: true,
+        configurable: true
+    },
+
+    reverse: {
+        value: function reverse() {
+
+            var reversed = this.constructClone(this);
+            reversed.reverse();
+            this.swap(0, this.length, reversed);
+
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    sort: {
+        value: function sort() {
+
+            // dispatch before change events
+            this.dispatchBeforeRangeChange(this, this, 0);
+            for (var i = 0; i < this.length; i++) {
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                this.dispatchBeforeMapChange(i, this[i]);
+            }
+
+            // actual work
+            array_sort.apply(this, arguments);
+
+            // dispatch after change events
+            for (var i = 0; i < this.length; i++) {
+                PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                this.dispatchMapChange(i, this[i]);
+            }
+            this.dispatchRangeChange(this, this, 0);
+
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    splice: {
+        value: function splice(start, length) {
+            var minus = array_slice.call(this, start, start + length);
+            var plus = array_slice.call(arguments, 2);
+            if (!minus.length && !plus.length)
+                return plus; // [], but spare us an instantiation
+            var diff = plus.length - minus.length;
+            var oldLength = this.length;
+            var newLength = Math.max(this.length + diff, start + plus.length);
+            var longest = Math.max(oldLength, newLength);
+
+            // dispatch before change events
+            if (diff) {
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, "length", this.length);
+            }
+            this.dispatchBeforeRangeChange(plus, minus, start);
+            if (diff === 0) { // substring replacement
+                for (var i = start; i < start + plus.length; i++) {
+                    PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                    this.dispatchBeforeMapChange(i, this[i]);
+                }
+            } else if (PropertyChanges.hasOwnPropertyChangeDescriptor(this)) {
+                // all subsequent values changed or shifted.
+                // avoid (longest - start) long walks if there are no
+                // registered descriptors.
+                for (var i = start; i < longest; i++) {
+                    PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                    this.dispatchBeforeMapChange(i, this[i]);
+                }
+            }
+
+            // actual work
+            if (start > oldLength) {
+                this.length = start;
+            }
+            var result = array_splice.apply(this, arguments);
+
+            // dispatch after change events
+            if (diff === 0) { // substring replacement
+                for (var i = start; i < start + plus.length; i++) {
+                    PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                    this.dispatchMapChange(i, this[i]);
+                }
+            } else if (PropertyChanges.hasOwnPropertyChangeDescriptor(this)) {
+                // all subsequent values changed or shifted.
+                // avoid (longest - start) long walks if there are no
+                // registered descriptors.
+                for (var i = start; i < longest; i++) {
+                    PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                    this.dispatchMapChange(i, this[i]);
+                }
+            }
+            this.dispatchRangeChange(plus, minus, start);
+            if (diff) {
+                PropertyChanges.dispatchOwnPropertyChange(this, "length", this.length);
+            }
+
+            return result;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    // splice is the array content change utility belt.  forward all other
+    // content changes to splice so we only have to write observer code in one
+    // place
+
+    set: {
+        value: function set(index, value) {
+            this.splice(index, 1, value);
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    shift: {
+        value: function shift() {
+            return this.splice(0, 1)[0];
+        },
+        writable: true,
+        configurable: true
+    },
+
+    pop: {
+        value: function pop() {
+            if (this.length) {
+                return this.splice(this.length - 1, 1)[0];
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    push: {
+        value: function push(arg) {
+            if (arguments.length === 1) {
+                return this.splice(this.length, 0, arg);
+            } else {
+                var args = array_slice.call(arguments);
+                return this.swap(this.length, 0, args);
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    unshift: {
+        value: function unshift(arg) {
+            if (arguments.length === 1) {
+                return this.splice(0, 0, arg);
+            } else {
+                var args = array_slice.call(arguments);
+                return this.swap(0, 0, args);
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    clear: {
+        value: function clear() {
+            return this.splice(0, this.length);
+        },
+        writable: true,
+        configurable: true
+    }
+
+};
+
+var ChangeDispatchArray = Object.create(Array.prototype, observableArrayProperties);
+
+
+},{"../list":46,"../shim":58,"./map-changes":48,"./property-changes":49,"./range-changes":50,"weak-map":52}],48:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+var List = require("../list");
+
+module.exports = MapChanges;
+function MapChanges() {
+    throw new Error("Can't construct. MapChanges is a mixin.");
+}
+
+var object_owns = Object.prototype.hasOwnProperty;
+
+/*
+    Object map change descriptors carry information necessary for adding,
+    removing, dispatching, and shorting events to listeners for map changes
+    for a particular key on a particular object.  These descriptors are used
+    here for shallow map changes.
+
+    {
+        willChangeListeners:Array(Function)
+        changeListeners:Array(Function)
+    }
+*/
+
+var mapChangeDescriptors = new WeakMap();
+
+MapChanges.prototype.getAllMapChangeDescriptors = function () {
+    var Dict = require("../dict");
+    if (!mapChangeDescriptors.has(this)) {
+        mapChangeDescriptors.set(this, Dict());
+    }
+    return mapChangeDescriptors.get(this);
+};
+
+MapChanges.prototype.getMapChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllMapChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            willChangeListeners: new List(),
+            changeListeners: new List()
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+MapChanges.prototype.addMapChangeListener = function (listener, token, beforeChange) {
+    if (!this.isObservable && this.makeObservable) {
+        // for Array
+        this.makeObservable();
+    }
+    var descriptor = this.getMapChangeDescriptor(token);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesMapChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelMapChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Can't remove map change listener again");
+            return;
+        }
+        self.removeMapChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+MapChanges.prototype.removeMapChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getMapChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var node = listeners.findLast(listener);
+    if (!node) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    node["delete"]();
+};
+
+MapChanges.prototype.dispatchMapChange = function (key, value, beforeChange) {
+    var descriptors = this.getAllMapChangeDescriptors();
+    var changeName = "Map" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+
+        try {
+            // dispatch to each listener
+            listeners.forEach(function (listener) {
+                if (listener[tokenName]) {
+                    listener[tokenName](value, key, this);
+                } else if (listener.call) {
+                    listener.call(listener, value, key, this);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+
+    }, this);
+};
+
+MapChanges.prototype.addBeforeMapChangeListener = function (listener, token) {
+    return this.addMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.removeBeforeMapChangeListener = function (listener, token) {
+    return this.removeMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.dispatchBeforeMapChange = function (key, value) {
+    return this.dispatchMapChange(key, value, true);
+};
+
+
+},{"../dict":39,"../list":46,"weak-map":52}],49:[function(require,module,exports){
+/*
+    Based in part on observable arrays from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/*
+    This module is responsible for observing changes to owned properties of
+    objects and changes to the content of arrays caused by method calls.
+    The interface for observing array content changes establishes the methods
+    necessary for any collection with observable content.
+*/
+
+require("../shim");
+var WeakMap = require("weak-map");
+
+var object_owns = Object.prototype.hasOwnProperty;
+
+/*
+    Object property descriptors carry information necessary for adding,
+    removing, dispatching, and shorting events to listeners for property changes
+    for a particular key on a particular object.  These descriptors are used
+    here for shallow property changes.
+
+    {
+        willChangeListeners:Array(Function)
+        changeListeners:Array(Function)
+    }
+*/
+var propertyChangeDescriptors = new WeakMap();
+
+// Maybe remove entries from this table if the corresponding object no longer
+// has any property change listeners for any key.  However, the cost of
+// book-keeping is probably not warranted since it would be rare for an
+// observed object to no longer be observed unless it was about to be disposed
+// of or reused as an observable.  The only benefit would be in avoiding bulk
+// calls to dispatchOwnPropertyChange events on objects that have no listeners.
+
+/*
+    To observe shallow property changes for a particular key of a particular
+    object, we install a property descriptor on the object that overrides the previous
+    descriptor.  The overridden descriptors are stored in this weak map.  The
+    weak map associates an object with another object that maps property names
+    to property descriptors.
+
+    overriddenObjectDescriptors.get(object)[key]
+
+    We retain the old descriptor for various purposes.  For one, if the property
+    is no longer being observed by anyone, we revert the property descriptor to
+    the original.  For "value" descriptors, we store the actual value of the
+    descriptor on the overridden descriptor, so when the property is reverted, it
+    retains the most recently set value.  For "get" and "set" descriptors,
+    we observe then forward "get" and "set" operations to the original descriptor.
+*/
+var overriddenObjectDescriptors = new WeakMap();
+
+module.exports = PropertyChanges;
+
+function PropertyChanges() {
+    throw new Error("This is an abstract interface. Mix it. Don't construct it");
+}
+
+PropertyChanges.debug = true;
+
+PropertyChanges.prototype.getOwnPropertyChangeDescriptor = function (key) {
+    if (!propertyChangeDescriptors.has(this)) {
+        propertyChangeDescriptors.set(this, {});
+    }
+    var objectPropertyChangeDescriptors = propertyChangeDescriptors.get(this);
+    if (!object_owns.call(objectPropertyChangeDescriptors, key)) {
+        objectPropertyChangeDescriptors[key] = {
+            willChangeListeners: [],
+            changeListeners: []
+        };
+    }
+    return objectPropertyChangeDescriptors[key];
+};
+
+PropertyChanges.prototype.hasOwnPropertyChangeDescriptor = function (key) {
+    if (!propertyChangeDescriptors.has(this)) {
+        return false;
+    }
+    if (!key) {
+        return true;
+    }
+    var objectPropertyChangeDescriptors = propertyChangeDescriptors.get(this);
+    if (!object_owns.call(objectPropertyChangeDescriptors, key)) {
+        return false;
+    }
+    return true;
+};
+
+PropertyChanges.prototype.addOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    if (this.makeObservable && !this.isObservable) {
+        this.makeObservable(); // particularly for observable arrays, for
+        // their length property
+    }
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    PropertyChanges.makePropertyObservable(this, key);
+    listeners.push(listener);
+
+    var self = this;
+    return function cancelOwnPropertyChangeListener() {
+        PropertyChanges.removeOwnPropertyChangeListener(self, key, listeners, beforeChange);
+        self = null;
+    };
+};
+
+PropertyChanges.prototype.addBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.removeOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    listeners.splice(index, 1);
+
+    if (descriptor.changeListeners.length + descriptor.willChangeListeners.length === 0) {
+        PropertyChanges.makePropertyUnobservable(this, key);
+    }
+};
+
+PropertyChanges.prototype.removeBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.dispatchOwnPropertyChange = function (key, value, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+
+    if (descriptor.isActive) {
+        return;
+    }
+    descriptor.isActive = true;
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var changeName = (beforeChange ? "Will" : "") + "Change";
+    var genericHandlerName = "handleProperty" + changeName;
+    var propertyName = String(key);
+    propertyName = propertyName && propertyName[0].toUpperCase() + propertyName.slice(1);
+    var specificHandlerName = "handle" + propertyName + changeName;
+
+    try {
+        // dispatch to each listener
+        listeners.forEach(function (listener) {
+            var thisp = listener;
+            listener = (
+                listener[specificHandlerName] ||
+                listener[genericHandlerName] ||
+                listener
+            );
+            if (!listener.call) {
+                throw new Error("No event listener for " + specificHandlerName + " or " + genericHandlerName + " or call on " + listener);
+            }
+            listener.call(thisp, value, key, this);
+        }, this);
+    } finally {
+        descriptor.isActive = false;
+    }
+};
+
+PropertyChanges.prototype.dispatchBeforeOwnPropertyChange = function (key, listener) {
+    return PropertyChanges.dispatchOwnPropertyChange(this, key, listener, true);
+};
+
+PropertyChanges.prototype.makePropertyObservable = function (key) {
+    // arrays are special.  we do not support direct setting of properties
+    // on an array.  instead, call .set(index, value).  this is observable.
+    // 'length' property is observable for all mutating methods because
+    // our overrides explicitly dispatch that change.
+    if (Array.isArray(this)) {
+        return;
+    }
+
+    if (!Object.isExtensible(this, key)) {
+        throw new Error("Can't make property " + JSON.stringify(key) + " observable on " + this + " because object is not extensible");
+    }
+
+    var state;
+    if (typeof this.__state__ === "object") {
+        state = this.__state__;
+    } else {
+        state = {};
+        if (Object.isExtensible(this, "__state__")) {
+            Object.defineProperty(this, "__state__", {
+                value: state,
+                writable: true,
+                enumerable: false
+            });
+        }
+    }
+    state[key] = this[key];
+
+    // memoize overridden property descriptor table
+    if (!overriddenObjectDescriptors.has(this)) {
+        overriddenPropertyDescriptors = {};
+        overriddenObjectDescriptors.set(this, overriddenPropertyDescriptors);
+    }
+    var overriddenPropertyDescriptors = overriddenObjectDescriptors.get(this);
+
+    if (object_owns.call(overriddenPropertyDescriptors, key)) {
+        // if we have already recorded an overridden property descriptor,
+        // we have already installed the observer, so short-here
+        return;
+    }
+
+    // walk up the prototype chain to find a property descriptor for
+    // the property name
+    var overriddenDescriptor;
+    var attached = this;
+    var formerDescriptor = Object.getOwnPropertyDescriptor(attached, key);
+    do {
+        overriddenDescriptor = Object.getOwnPropertyDescriptor(attached, key);
+        if (overriddenDescriptor) {
+            break;
+        }
+        attached = Object.getPrototypeOf(attached);
+    } while (attached);
+    // or default to an undefined value
+    overriddenDescriptor = overriddenDescriptor || {
+        value: undefined,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    };
+
+    if (!overriddenDescriptor.configurable) {
+        throw new Error("Can't observe non-configurable properties");
+    }
+
+    // memoize the descriptor so we know not to install another layer,
+    // and so we can reuse the overridden descriptor when uninstalling
+    overriddenPropertyDescriptors[key] = overriddenDescriptor;
+
+    // give up *after* storing the overridden property descriptor so it
+    // can be restored by uninstall.  Unwritable properties are
+    // silently not overriden.  Since success is indistinguishable from
+    // failure, we let it pass but don't waste time on intercepting
+    // get/set.
+    if (!overriddenDescriptor.writable && !overriddenDescriptor.set) {
+        return;
+    }
+
+    // TODO reflect current value on a displayed property
+
+    var propertyListener;
+    // in both of these new descriptor variants, we reuse the overridden
+    // descriptor to either store the current value or apply getters
+    // and setters.  this is handy since we can reuse the overridden
+    // descriptor if we uninstall the observer.  We even preserve the
+    // assignment semantics, where we get the value from up the
+    // prototype chain, and set as an owned property.
+    if ('value' in overriddenDescriptor) {
+        propertyListener = {
+            get: function () {
+                return overriddenDescriptor.value
+            },
+            set: function (value) {
+                if (value === overriddenDescriptor.value) {
+                    return value;
+                }
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, key, overriddenDescriptor.value);
+                overriddenDescriptor.value = value;
+                state[key] = value;
+                PropertyChanges.dispatchOwnPropertyChange(this, key, value);
+                return value;
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    } else { // 'get' or 'set', but not necessarily both
+        propertyListener = {
+            get: function () {
+                if (overriddenDescriptor.get) {
+                    return overriddenDescriptor.get.apply(this, arguments);
+                }
+            },
+            set: function (value) {
+                var formerValue;
+
+                // get the actual former value if possible
+                if (overriddenDescriptor.get) {
+                    formerValue = overriddenDescriptor.get.apply(this, arguments);
+                }
+                // call through to actual setter
+                if (overriddenDescriptor.set) {
+                    overriddenDescriptor.set.apply(this, arguments)
+                }
+                // use getter, if possible, to discover whether the set
+                // was successful
+                if (overriddenDescriptor.get) {
+                    value = overriddenDescriptor.get.apply(this, arguments);
+                    state[key] = value;
+                }
+                // if it has not changed, suppress a notification
+                if (value === formerValue) {
+                    return value;
+                }
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, key, formerValue);
+
+                // dispatch the new value: the given value if there is
+                // no getter, or the actual value if there is one
+                PropertyChanges.dispatchOwnPropertyChange(this, key, value);
+                return value;
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    }
+
+    Object.defineProperty(this, key, propertyListener);
+};
+
+PropertyChanges.prototype.makePropertyUnobservable = function (key) {
+    // arrays are special.  we do not support direct setting of properties
+    // on an array.  instead, call .set(index, value).  this is observable.
+    // 'length' property is observable for all mutating methods because
+    // our overrides explicitly dispatch that change.
+    if (Array.isArray(this)) {
+        return;
+    }
+
+    if (!overriddenObjectDescriptors.has(this)) {
+        throw new Error("Can't uninstall observer on property");
+    }
+    var overriddenPropertyDescriptors = overriddenObjectDescriptors.get(this);
+
+    if (!overriddenPropertyDescriptors[key]) {
+        throw new Error("Can't uninstall observer on property");
+    }
+
+    var overriddenDescriptor = overriddenPropertyDescriptors[key];
+    delete overriddenPropertyDescriptors[key];
+
+    var state;
+    if (typeof this.__state__ === "object") {
+        state = this.__state__;
+    } else {
+        state = {};
+        if (Object.isExtensible(this, "__state__")) {
+            Object.defineProperty(this, "__state__", {
+                value: state,
+                writable: true,
+                enumerable: false
+            });
+        }
+    }
+    delete state[key];
+
+    Object.defineProperty(this, key, overriddenDescriptor);
+};
+
+// constructor functions
+
+PropertyChanges.getOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.getOwnPropertyChangeDescriptor) {
+        return object.getOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.getOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.hasOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.hasOwnPropertyChangeDescriptor) {
+        return object.hasOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.hasOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.addOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.addOwnPropertyChangeListener) {
+        return object.addOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.addOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.removeOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.removeOwnPropertyChangeListener) {
+        return object.removeOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.removeOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.dispatchOwnPropertyChange = function (object, key, value, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.dispatchOwnPropertyChange) {
+        return object.dispatchOwnPropertyChange(key, value, beforeChange);
+    } else {
+        return PropertyChanges.prototype.dispatchOwnPropertyChange.call(object, key, value, beforeChange);
+    }
+};
+
+PropertyChanges.addBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.removeBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.dispatchBeforeOwnPropertyChange = function (object, key, value) {
+    return PropertyChanges.dispatchOwnPropertyChange(object, key, value, true);
+};
+
+PropertyChanges.makePropertyObservable = function (object, key) {
+    if (object.makePropertyObservable) {
+        return object.makePropertyObservable(key);
+    } else {
+        return PropertyChanges.prototype.makePropertyObservable.call(object, key);
+    }
+};
+
+PropertyChanges.makePropertyUnobservable = function (object, key) {
+    if (object.makePropertyUnobservable) {
+        return object.makePropertyUnobservable(key);
+    } else {
+        return PropertyChanges.prototype.makePropertyUnobservable.call(object, key);
+    }
+};
+
+
+},{"../shim":58,"weak-map":52}],50:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+var Dict = require("../dict");
+
+var rangeChangeDescriptors = new WeakMap(); // {isActive, willChangeListeners, changeListeners}
+
+module.exports = RangeChanges;
+function RangeChanges() {
+    throw new Error("Can't construct. RangeChanges is a mixin.");
+}
+
+RangeChanges.prototype.getAllRangeChangeDescriptors = function () {
+    if (!rangeChangeDescriptors.has(this)) {
+        rangeChangeDescriptors.set(this, Dict());
+    }
+    return rangeChangeDescriptors.get(this);
+};
+
+RangeChanges.prototype.getRangeChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllRangeChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            isActive: false,
+            changeListeners: [],
+            willChangeListeners: []
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+RangeChanges.prototype.addRangeChangeListener = function (listener, token, beforeChange) {
+    // a concession for objects like Array that are not inherently observable
+    if (!this.isObservable && this.makeObservable) {
+        this.makeObservable();
+    }
+
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    // even if already registered
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesRangeChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelRangeChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Range change listener " + JSON.stringify(token) + " has already been canceled");
+            return;
+        }
+        self.removeRangeChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+RangeChanges.prototype.removeRangeChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    listeners.splice(index, 1);
+};
+
+RangeChanges.prototype.dispatchRangeChange = function (plus, minus, index, beforeChange) {
+    var descriptors = this.getAllRangeChangeDescriptors();
+    var changeName = "Range" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        // before or after
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+        // notably, defaults to "handleRangeChange" or "handleRangeWillChange"
+        // if token is "" (the default)
+
+        // dispatch each listener
+        try {
+            listeners.forEach(function (listener) {
+                if (listener[tokenName]) {
+                    listener[tokenName](plus, minus, index, this, beforeChange);
+                } else if (listener.call) {
+                    listener.call(this, plus, minus, index, this, beforeChange);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+    }, this);
+};
+
+RangeChanges.prototype.addBeforeRangeChangeListener = function (listener, token) {
+    return this.addRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.removeBeforeRangeChangeListener = function (listener, token) {
+    return this.removeRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.dispatchBeforeRangeChange = function (plus, minus, index) {
+    return this.dispatchRangeChange(plus, minus, index, true);
+};
+
+
+},{"../dict":39,"weak-map":52}],51:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var Set = require("./set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = Map;
+
+function Map(values, equals, hash, getDefault) {
+    if (!(this instanceof Map)) {
+        return new Map(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    this.store = new Set(
+        undefined,
+        function keysEqual(a, b) {
+            return equals(a.key, b.key);
+        },
+        function keyHash(item) {
+            return hash(item.key);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+Map.Map = Map; // hack so require("map").Map will work in MontageJS
+
+Object.addEach(Map.prototype, GenericCollection.prototype);
+Object.addEach(Map.prototype, GenericMap.prototype); // overrides GenericCollection
+Object.addEach(Map.prototype, PropertyChanges.prototype);
+
+Map.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+Map.prototype.log = function (charmap, logNode, callback, thisp) {
+    logNode = logNode || this.logNode;
+    this.store.log(charmap, function (node, log, logBefore) {
+        logNode(node.value.value, log, logBefore);
+    }, callback, thisp);
+};
+
+Map.prototype.logNode = function (node, log) {
+    log(' key: ' + node.key);
+    log(' value: ' + node.value);
+};
+
+
+},{"./generic-collection":41,"./generic-map":42,"./listen/property-changes":49,"./set":53,"./shim":58}],52:[function(require,module,exports){
+// Copyright (C) 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Install a leaky WeakMap emulation on platforms that
+ * don't provide a built-in one.
+ *
+ * <p>Assumes that an ES5 platform where, if {@code WeakMap} is
+ * already present, then it conforms to the anticipated ES6
+ * specification. To run this file on an ES5 or almost ES5
+ * implementation where the {@code WeakMap} specification does not
+ * quite conform, run <code>repairES5.js</code> first.
+ *
+ * <p> Even though WeakMapModule is not global, the linter thinks it
+ * is, which is why it is in the overrides list below.
+ *
+ * @author Mark S. Miller
+ * @requires crypto, ArrayBuffer, Uint8Array, navigator
+ * @overrides WeakMap, ses, Proxy
+ * @overrides WeakMapModule
+ */
+
+/**
+ * This {@code WeakMap} emulation is observably equivalent to the
+ * ES-Harmony WeakMap, but with leakier garbage collection properties.
+ *
+ * <p>As with true WeakMaps, in this emulation, a key does not
+ * retain maps indexed by that key and (crucially) a map does not
+ * retain the keys it indexes. A map by itself also does not retain
+ * the values associated with that map.
+ *
+ * <p>However, the values associated with a key in some map are
+ * retained so long as that key is retained and those associations are
+ * not overridden. For example, when used to support membranes, all
+ * values exported from a given membrane will live for the lifetime
+ * they would have had in the absence of an interposed membrane. Even
+ * when the membrane is revoked, all objects that would have been
+ * reachable in the absence of revocation will still be reachable, as
+ * far as the GC can tell, even though they will no longer be relevant
+ * to ongoing computation.
+ *
+ * <p>The API implemented here is approximately the API as implemented
+ * in FF6.0a1 and agreed to by MarkM, Andreas Gal, and Dave Herman,
+ * rather than the offially approved proposal page. TODO(erights):
+ * upgrade the ecmascript WeakMap proposal page to explain this API
+ * change and present to EcmaScript committee for their approval.
+ *
+ * <p>The first difference between the emulation here and that in
+ * FF6.0a1 is the presence of non enumerable {@code get___, has___,
+ * set___, and delete___} methods on WeakMap instances to represent
+ * what would be the hidden internal properties of a primitive
+ * implementation. Whereas the FF6.0a1 WeakMap.prototype methods
+ * require their {@code this} to be a genuine WeakMap instance (i.e.,
+ * an object of {@code [[Class]]} "WeakMap}), since there is nothing
+ * unforgeable about the pseudo-internal method names used here,
+ * nothing prevents these emulated prototype methods from being
+ * applied to non-WeakMaps with pseudo-internal methods of the same
+ * names.
+ *
+ * <p>Another difference is that our emulated {@code
+ * WeakMap.prototype} is not itself a WeakMap. A problem with the
+ * current FF6.0a1 API is that WeakMap.prototype is itself a WeakMap
+ * providing ambient mutability and an ambient communications
+ * channel. Thus, if a WeakMap is already present and has this
+ * problem, repairES5.js wraps it in a safe wrappper in order to
+ * prevent access to this channel. (See
+ * PATCH_MUTABLE_FROZEN_WEAKMAP_PROTO in repairES5.js).
+ */
+
+/**
+ * If this is a full <a href=
+ * "http://code.google.com/p/es-lab/wiki/SecureableES5"
+ * >secureable ES5</a> platform and the ES-Harmony {@code WeakMap} is
+ * absent, install an approximate emulation.
+ *
+ * <p>If WeakMap is present but cannot store some objects, use our approximate
+ * emulation as a wrapper.
+ *
+ * <p>If this is almost a secureable ES5 platform, then WeakMap.js
+ * should be run after repairES5.js.
+ *
+ * <p>See {@code WeakMap} for documentation of the garbage collection
+ * properties of this WeakMap emulation.
+ */
+(function WeakMapModule() {
+  "use strict";
+
+  if (typeof ses !== 'undefined' && ses.ok && !ses.ok()) {
+    // already too broken, so give up
+    return;
+  }
+
+  /**
+   * In some cases (current Firefox), we must make a choice betweeen a
+   * WeakMap which is capable of using all varieties of host objects as
+   * keys and one which is capable of safely using proxies as keys. See
+   * comments below about HostWeakMap and DoubleWeakMap for details.
+   *
+   * This function (which is a global, not exposed to guests) marks a
+   * WeakMap as permitted to do what is necessary to index all host
+   * objects, at the cost of making it unsafe for proxies.
+   *
+   * Do not apply this function to anything which is not a genuine
+   * fresh WeakMap.
+   */
+  function weakMapPermitHostObjects(map) {
+    // identity of function used as a secret -- good enough and cheap
+    if (map.permitHostObjects___) {
+      map.permitHostObjects___(weakMapPermitHostObjects);
+    }
+  }
+  if (typeof ses !== 'undefined') {
+    ses.weakMapPermitHostObjects = weakMapPermitHostObjects;
+  }
+
+  // Check if there is already a good-enough WeakMap implementation, and if so
+  // exit without replacing it.
+  if (typeof WeakMap === 'function') {
+    var HostWeakMap = WeakMap;
+    // There is a WeakMap -- is it good enough?
+    if (typeof navigator !== 'undefined' &&
+        /Firefox/.test(navigator.userAgent)) {
+      // We're now *assuming not*, because as of this writing (2013-05-06)
+      // Firefox's WeakMaps have a miscellany of objects they won't accept, and
+      // we don't want to make an exhaustive list, and testing for just one
+      // will be a problem if that one is fixed alone (as they did for Event).
+
+      // If there is a platform that we *can* reliably test on, here's how to
+      // do it:
+      //  var problematic = ... ;
+      //  var testHostMap = new HostWeakMap();
+      //  try {
+      //    testHostMap.set(problematic, 1);  // Firefox 20 will throw here
+      //    if (testHostMap.get(problematic) === 1) {
+      //      return;
+      //    }
+      //  } catch (e) {}
+
+      // Fall through to installing our WeakMap.
+    } else {
+      module.exports = WeakMap;
+      return;
+    }
+  }
+
+  var hop = Object.prototype.hasOwnProperty;
+  var gopn = Object.getOwnPropertyNames;
+  var defProp = Object.defineProperty;
+  var isExtensible = Object.isExtensible;
+
+  /**
+   * Security depends on HIDDEN_NAME being both <i>unguessable</i> and
+   * <i>undiscoverable</i> by untrusted code.
+   *
+   * <p>Given the known weaknesses of Math.random() on existing
+   * browsers, it does not generate unguessability we can be confident
+   * of.
+   *
+   * <p>It is the monkey patching logic in this file that is intended
+   * to ensure undiscoverability. The basic idea is that there are
+   * three fundamental means of discovering properties of an object:
+   * The for/in loop, Object.keys(), and Object.getOwnPropertyNames(),
+   * as well as some proposed ES6 extensions that appear on our
+   * whitelist. The first two only discover enumerable properties, and
+   * we only use HIDDEN_NAME to name a non-enumerable property, so the
+   * only remaining threat should be getOwnPropertyNames and some
+   * proposed ES6 extensions that appear on our whitelist. We monkey
+   * patch them to remove HIDDEN_NAME from the list of properties they
+   * returns.
+   *
+   * <p>TODO(erights): On a platform with built-in Proxies, proxies
+   * could be used to trap and thereby discover the HIDDEN_NAME, so we
+   * need to monkey patch Proxy.create, Proxy.createFunction, etc, in
+   * order to wrap the provided handler with the real handler which
+   * filters out all traps using HIDDEN_NAME.
+   *
+   * <p>TODO(erights): Revisit Mike Stay's suggestion that we use an
+   * encapsulated function at a not-necessarily-secret name, which
+   * uses the Stiegler shared-state rights amplification pattern to
+   * reveal the associated value only to the WeakMap in which this key
+   * is associated with that value. Since only the key retains the
+   * function, the function can also remember the key without causing
+   * leakage of the key, so this doesn't violate our general gc
+   * goals. In addition, because the name need not be a guarded
+   * secret, we could efficiently handle cross-frame frozen keys.
+   */
+  var HIDDEN_NAME_PREFIX = 'weakmap:';
+  var HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'ident:' + Math.random() + '___';
+
+  if (typeof crypto !== 'undefined' &&
+      typeof crypto.getRandomValues === 'function' &&
+      typeof ArrayBuffer === 'function' &&
+      typeof Uint8Array === 'function') {
+    var ab = new ArrayBuffer(25);
+    var u8s = new Uint8Array(ab);
+    crypto.getRandomValues(u8s);
+    HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'rand:' +
+      Array.prototype.map.call(u8s, function(u8) {
+        return (u8 % 36).toString(36);
+      }).join('') + '___';
+  }
+
+  function isNotHiddenName(name) {
+    return !(
+        name.substr(0, HIDDEN_NAME_PREFIX.length) == HIDDEN_NAME_PREFIX &&
+        name.substr(name.length - 3) === '___');
+  }
+
+  /**
+   * Monkey patch getOwnPropertyNames to avoid revealing the
+   * HIDDEN_NAME.
+   *
+   * <p>The ES5.1 spec requires each name to appear only once, but as
+   * of this writing, this requirement is controversial for ES6, so we
+   * made this code robust against this case. If the resulting extra
+   * search turns out to be expensive, we can probably relax this once
+   * ES6 is adequately supported on all major browsers, iff no browser
+   * versions we support at that time have relaxed this constraint
+   * without providing built-in ES6 WeakMaps.
+   */
+  defProp(Object, 'getOwnPropertyNames', {
+    value: function fakeGetOwnPropertyNames(obj) {
+      return gopn(obj).filter(isNotHiddenName);
+    }
+  });
+
+  /**
+   * getPropertyNames is not in ES5 but it is proposed for ES6 and
+   * does appear in our whitelist, so we need to clean it too.
+   */
+  if ('getPropertyNames' in Object) {
+    var originalGetPropertyNames = Object.getPropertyNames;
+    defProp(Object, 'getPropertyNames', {
+      value: function fakeGetPropertyNames(obj) {
+        return originalGetPropertyNames(obj).filter(isNotHiddenName);
+      }
+    });
+  }
+
+  /**
+   * <p>To treat objects as identity-keys with reasonable efficiency
+   * on ES5 by itself (i.e., without any object-keyed collections), we
+   * need to add a hidden property to such key objects when we
+   * can. This raises several issues:
+   * <ul>
+   * <li>Arranging to add this property to objects before we lose the
+   *     chance, and
+   * <li>Hiding the existence of this new property from most
+   *     JavaScript code.
+   * <li>Preventing <i>certification theft</i>, where one object is
+   *     created falsely claiming to be the key of an association
+   *     actually keyed by another object.
+   * <li>Preventing <i>value theft</i>, where untrusted code with
+   *     access to a key object but not a weak map nevertheless
+   *     obtains access to the value associated with that key in that
+   *     weak map.
+   * </ul>
+   * We do so by
+   * <ul>
+   * <li>Making the name of the hidden property unguessable, so "[]"
+   *     indexing, which we cannot intercept, cannot be used to access
+   *     a property without knowing the name.
+   * <li>Making the hidden property non-enumerable, so we need not
+   *     worry about for-in loops or {@code Object.keys},
+   * <li>monkey patching those reflective methods that would
+   *     prevent extensions, to add this hidden property first,
+   * <li>monkey patching those methods that would reveal this
+   *     hidden property.
+   * </ul>
+   * Unfortunately, because of same-origin iframes, we cannot reliably
+   * add this hidden property before an object becomes
+   * non-extensible. Instead, if we encounter a non-extensible object
+   * without a hidden record that we can detect (whether or not it has
+   * a hidden record stored under a name secret to us), then we just
+   * use the key object itself to represent its identity in a brute
+   * force leaky map stored in the weak map, losing all the advantages
+   * of weakness for these.
+   */
+  function getHiddenRecord(key) {
+    if (key !== Object(key)) {
+      throw new TypeError('Not an object: ' + key);
+    }
+    var hiddenRecord = key[HIDDEN_NAME];
+    if (hiddenRecord && hiddenRecord.key === key) { return hiddenRecord; }
+    if (!isExtensible(key)) {
+      // Weak map must brute force, as explained in doc-comment above.
+      return void 0;
+    }
+    var gets = [];
+    var vals = [];
+    hiddenRecord = {
+      key: key,   // self pointer for quick own check above.
+      gets: gets, // get___ methods identifying weak maps
+      vals: vals  // values associated with this key in each
+                  // corresponding weak map.
+    };
+    defProp(key, HIDDEN_NAME, {
+      value: hiddenRecord,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    return hiddenRecord;
+  }
+
+
+  /**
+   * Monkey patch operations that would make their argument
+   * non-extensible.
+   *
+   * <p>The monkey patched versions throw a TypeError if their
+   * argument is not an object, so it should only be done to functions
+   * that should throw a TypeError anyway if their argument is not an
+   * object.
+   */
+  (function(){
+    var oldFreeze = Object.freeze;
+    defProp(Object, 'freeze', {
+      value: function identifyingFreeze(obj) {
+        getHiddenRecord(obj);
+        return oldFreeze(obj);
+      }
+    });
+    var oldSeal = Object.seal;
+    defProp(Object, 'seal', {
+      value: function identifyingSeal(obj) {
+        getHiddenRecord(obj);
+        return oldSeal(obj);
+      }
+    });
+    var oldPreventExtensions = Object.preventExtensions;
+    defProp(Object, 'preventExtensions', {
+      value: function identifyingPreventExtensions(obj) {
+        getHiddenRecord(obj);
+        return oldPreventExtensions(obj);
+      }
+    });
+  })();
+
+
+  function constFunc(func) {
+    func.prototype = null;
+    return Object.freeze(func);
+  }
+
+  // Right now (12/25/2012) the histogram supports the current
+  // representation. We should check this occasionally, as a true
+  // constant time representation is easy.
+  // var histogram = [];
+
+  var OurWeakMap = function() {
+    // We are currently (12/25/2012) never encountering any prematurely
+    // non-extensible keys.
+    var keys = []; // brute force for prematurely non-extensible keys.
+    var vals = []; // brute force for corresponding values.
+
+    function get___(key, opt_default) {
+      var hr = getHiddenRecord(key);
+      var i, vs;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        vs = hr.vals;
+      } else {
+        i = keys.indexOf(key);
+        vs = vals;
+      }
+      return (i >= 0) ? vs[i] : opt_default;
+    }
+
+    function has___(key) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+      } else {
+        i = keys.indexOf(key);
+      }
+      return i >= 0;
+    }
+
+    function set___(key, value) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        if (i >= 0) {
+          hr.vals[i] = value;
+        } else {
+//          i = hr.gets.length;
+//          histogram[i] = (histogram[i] || 0) + 1;
+          hr.gets.push(get___);
+          hr.vals.push(value);
+        }
+      } else {
+        i = keys.indexOf(key);
+        if (i >= 0) {
+          vals[i] = value;
+        } else {
+          keys.push(key);
+          vals.push(value);
+        }
+      }
+    }
+
+    function delete___(key) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        if (i >= 0) {
+          hr.gets.splice(i, 1);
+          hr.vals.splice(i, 1);
+        }
+      } else {
+        i = keys.indexOf(key);
+        if (i >= 0) {
+          keys.splice(i, 1);
+          vals.splice(i, 1);
+        }
+      }
+      return true;
+    }
+
+    return Object.create(OurWeakMap.prototype, {
+      get___:    { value: constFunc(get___) },
+      has___:    { value: constFunc(has___) },
+      set___:    { value: constFunc(set___) },
+      delete___: { value: constFunc(delete___) }
+    });
+  };
+  OurWeakMap.prototype = Object.create(Object.prototype, {
+    get: {
+      /**
+       * Return the value most recently associated with key, or
+       * opt_default if none.
+       */
+      value: function get(key, opt_default) {
+        return this.get___(key, opt_default);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    has: {
+      /**
+       * Is there a value associated with key in this WeakMap?
+       */
+      value: function has(key) {
+        return this.has___(key);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    set: {
+      /**
+       * Associate value with key in this WeakMap, overwriting any
+       * previous association if present.
+       */
+      value: function set(key, value) {
+        this.set___(key, value);
+      },
+      writable: true,
+      configurable: true
+    },
+
+    'delete': {
+      /**
+       * Remove any association for key in this WeakMap, returning
+       * whether there was one.
+       *
+       * <p>Note that the boolean return here does not work like the
+       * {@code delete} operator. The {@code delete} operator returns
+       * whether the deletion succeeds at bringing about a state in
+       * which the deleted property is absent. The {@code delete}
+       * operator therefore returns true if the property was already
+       * absent, whereas this {@code delete} method returns false if
+       * the association was already absent.
+       */
+      value: function remove(key) {
+        return this.delete___(key);
+      },
+      writable: true,
+      configurable: true
+    }
+  });
+
+  if (typeof HostWeakMap === 'function') {
+    (function() {
+      // If we got here, then the platform has a WeakMap but we are concerned
+      // that it may refuse to store some key types. Therefore, make a map
+      // implementation which makes use of both as possible.
+
+      function DoubleWeakMap() {
+        // Preferable, truly weak map.
+        var hmap = new HostWeakMap();
+
+        // Our hidden-property-based pseudo-weak-map. Lazily initialized in the
+        // 'set' implementation; thus we can avoid performing extra lookups if
+        // we know all entries actually stored are entered in 'hmap'.
+        var omap = undefined;
+
+        // Hidden-property maps are not compatible with proxies because proxies
+        // can observe the hidden name and either accidentally expose it or fail
+        // to allow the hidden property to be set. Therefore, we do not allow
+        // arbitrary WeakMaps to switch to using hidden properties, but only
+        // those which need the ability, and unprivileged code is not allowed
+        // to set the flag.
+        var enableSwitching = false;
+
+        function dget(key, opt_default) {
+          if (omap) {
+            return hmap.has(key) ? hmap.get(key)
+                : omap.get___(key, opt_default);
+          } else {
+            return hmap.get(key, opt_default);
+          }
+        }
+
+        function dhas(key) {
+          return hmap.has(key) || (omap ? omap.has___(key) : false);
+        }
+
+        function dset(key, value) {
+          if (enableSwitching) {
+            try {
+              hmap.set(key, value);
+            } catch (e) {
+              if (!omap) { omap = new OurWeakMap(); }
+              omap.set___(key, value);
+            }
+          } else {
+            hmap.set(key, value);
+          }
+        }
+
+        function ddelete(key) {
+          hmap['delete'](key);
+          if (omap) { omap.delete___(key); }
+        }
+
+        return Object.create(OurWeakMap.prototype, {
+          get___:    { value: constFunc(dget) },
+          has___:    { value: constFunc(dhas) },
+          set___:    { value: constFunc(dset) },
+          delete___: { value: constFunc(ddelete) },
+          permitHostObjects___: { value: constFunc(function(token) {
+            if (token === weakMapPermitHostObjects) {
+              enableSwitching = true;
+            } else {
+              throw new Error('bogus call to permitHostObjects___');
+            }
+          })}
+        });
+      }
+      DoubleWeakMap.prototype = OurWeakMap.prototype;
+      module.exports = DoubleWeakMap;
+
+      // define .constructor to hide OurWeakMap ctor
+      Object.defineProperty(WeakMap.prototype, 'constructor', {
+        value: WeakMap,
+        enumerable: false,  // as default .constructor is
+        configurable: true,
+        writable: true
+      });
+    })();
+  } else {
+    // There is no host WeakMap, so we must use the emulation.
+
+    // Emulated WeakMaps are incompatible with native proxies (because proxies
+    // can observe the hidden name), so we must disable Proxy usage (in
+    // ArrayLike and Domado, currently).
+    if (typeof Proxy !== 'undefined') {
+      Proxy = undefined;
+    }
+
+    module.exports = OurWeakMap;
+  }
+})();
+
+},{}],53:[function(require,module,exports){
+"use strict";
+
+var Shim = require("./shim");
+var List = require("./list");
+var FastSet = require("./fast-set");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+module.exports = Set;
+
+function Set(values, equals, hash, getDefault) {
+    if (!(this instanceof Set)) {
+        return new Set(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    // a list of values in insertion order, used for all operations that depend
+    // on iterating in insertion order
+    this.order = new this.Order(undefined, equals);
+    // a set of nodes from the order list, indexed by the corresponding value,
+    // used for all operations that need to quickly seek  value in the list
+    this.store = new this.Store(
+        undefined,
+        function (a, b) {
+            return equals(a.value, b.value);
+        },
+        function (node) {
+            return hash(node.value);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+Set.Set = Set; // hack so require("set").Set will work in MontageJS
+
+Object.addEach(Set.prototype, GenericCollection.prototype);
+Object.addEach(Set.prototype, GenericSet.prototype);
+Object.addEach(Set.prototype, PropertyChanges.prototype);
+Object.addEach(Set.prototype, RangeChanges.prototype);
+
+Set.prototype.Order = List;
+Set.prototype.Store = FastSet;
+
+Set.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.contentEquals, this.contentHash, this.getDefault);
+};
+
+Set.prototype.has = function (value) {
+    var node = new this.order.Node(value);
+    return this.store.has(node);
+};
+
+Set.prototype.get = function (value) {
+    var node = new this.order.Node(value);
+    node = this.store.get(node);
+    if (node) {
+        return node.value;
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+Set.prototype.add = function (value) {
+    var node = new this.order.Node(value);
+    if (!this.store.has(node)) {
+        var index = this.length;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([value], [], index);
+        }
+        this.order.add(value);
+        node = this.order.head.prev;
+        this.store.add(node);
+        this.length++;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([value], [], index);
+        }
+        return true;
+    }
+    return false;
+};
+
+Set.prototype["delete"] = function (value) {
+    var node = new this.order.Node(value);
+    if (this.store.has(node)) {
+        var node = this.store.get(node);
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([], [value], node.index);
+        }
+        this.store["delete"](node); // removes from the set
+        this.order.splice(node, 1); // removes the node from the list
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([], [value], node.index);
+        }
+        return true;
+    }
+    return false;
+};
+
+Set.prototype.pop = function () {
+    if (this.length) {
+        var result = this.order.head.prev.value;
+        this["delete"](result);
+        return result;
+    }
+};
+
+Set.prototype.shift = function () {
+    if (this.length) {
+        var result = this.order.head.next.value;
+        this["delete"](result);
+        return result;
+    }
+};
+
+Set.prototype.one = function () {
+    if (this.length > 0) {
+        return this.store.one().value;
+    }
+};
+
+Set.prototype.clear = function () {
+    var clearing;
+    if (this.dispatchesRangeChanges) {
+        clearing = this.toArray();
+        this.dispatchBeforeRangeChange([], clearing, 0);
+    }
+    this.store.clear();
+    this.order.clear();
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], clearing, 0);
+    }
+};
+
+Set.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var list = this.order;
+    var index = 0;
+    return list.reduce(function (basis, value) {
+        return callback.call(thisp, basis, value, index++, this);
+    }, basis, this);
+};
+
+Set.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var list = this.order;
+    var index = this.length - 1;
+    return list.reduceRight(function (basis, value) {
+        return callback.call(thisp, basis, value, index--, this);
+    }, basis, this);
+};
+
+Set.prototype.iterate = function () {
+    return this.order.iterate();
+};
+
+Set.prototype.log = function () {
+    var set = this.store;
+    return set.log.apply(set, arguments);
+};
+
+Set.prototype.makeObservable = function () {
+    this.order.makeObservable();
+};
+
+
+},{"./fast-set":40,"./generic-collection":41,"./generic-set":44,"./list":46,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],54:[function(require,module,exports){
+"use strict";
+
+/*
+    Based in part on extras from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+var Function = require("./shim-function");
+var GenericCollection = require("./generic-collection");
+var GenericOrder = require("./generic-order");
+var WeakMap = require("weak-map");
+
+module.exports = Array;
+
+Array.empty = [];
+
+if (Object.freeze) {
+    Object.freeze(Array.empty);
+}
+
+Array.from = function (values) {
+    var array = [];
+    array.addEach(values);
+    return array;
+};
+
+Array.unzip = function (table) {
+    var transpose = [];
+    var length = Infinity;
+    // compute shortest row
+    for (var i = 0; i < table.length; i++) {
+        var row = table[i];
+        table[i] = row.toArray();
+        if (row.length < length) {
+            length = row.length;
+        }
+    }
+    for (var i = 0; i < table.length; i++) {
+        var row = table[i];
+        for (var j = 0; j < row.length; j++) {
+            if (j < length && j in row) {
+                transpose[j] = transpose[j] || [];
+                transpose[j][i] = row[j];
+            }
+        }
+    }
+    return transpose;
+};
+
+function define(key, value) {
+    Object.defineProperty(Array.prototype, key, {
+        value: value,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+}
+
+define("addEach", GenericCollection.prototype.addEach);
+define("deleteEach", GenericCollection.prototype.deleteEach);
+define("toArray", GenericCollection.prototype.toArray);
+define("toObject", GenericCollection.prototype.toObject);
+define("all", GenericCollection.prototype.all);
+define("any", GenericCollection.prototype.any);
+define("min", GenericCollection.prototype.min);
+define("max", GenericCollection.prototype.max);
+define("sum", GenericCollection.prototype.sum);
+define("average", GenericCollection.prototype.average);
+define("only", GenericCollection.prototype.only);
+define("flatten", GenericCollection.prototype.flatten);
+define("zip", GenericCollection.prototype.zip);
+define("enumerate", GenericCollection.prototype.enumerate);
+define("group", GenericCollection.prototype.group);
+define("sorted", GenericCollection.prototype.sorted);
+define("reversed", GenericCollection.prototype.reversed);
+
+define("constructClone", function (values) {
+    var clone = new this.constructor();
+    clone.addEach(values);
+    return clone;
+});
+
+define("has", function (value, equals) {
+    return this.find(value, equals) !== -1;
+});
+
+define("get", function (index, defaultValue) {
+    if (+index !== index)
+        throw new Error("Indicies must be numbers");
+    if (!index in this) {
+        return defaultValue;
+    } else {
+        return this[index];
+    }
+});
+
+define("set", function (index, value) {
+    this.splice(index, 1, value);
+    return true;
+});
+
+define("add", function (value) {
+    this.push(value);
+    return true;
+});
+
+define("delete", function (value, equals) {
+    var index = this.find(value, equals);
+    if (index !== -1) {
+        this.splice(index, 1);
+        return true;
+    }
+    return false;
+});
+
+define("find", function (value, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+    for (var index = 0; index < this.length; index++) {
+        if (index in this && equals(this[index], value)) {
+            return index;
+        }
+    }
+    return -1;
+});
+
+define("findLast", function (value, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+    var index = this.length;
+    do {
+        index--;
+        if (index in this && equals(this[index], value)) {
+            return index;
+        }
+    } while (index > 0);
+    return -1;
+});
+
+define("swap", function (index, length, plus) {
+    var args = Array.prototype.slice.call(arguments, 0, 2);
+    if (plus) {
+        if (!Array.isArray(plus)) {
+            plus = Array.prototype.slice.call(plus);
+        }
+        args.push.apply(args, plus);
+    }
+    return this.splice.apply(this, args);
+});
+
+define("one", function () {
+    for (var i in this) {
+        if (Object.owns(this, i)) {
+            return this[i];
+        }
+    }
+});
+
+define("clear", function () {
+    this.length = 0;
+    return this;
+});
+
+define("compare", function (that, compare) {
+    compare = compare || Object.compare;
+    var i;
+    var length;
+    var lhs;
+    var rhs;
+    var relative;
+
+    if (this === that) {
+        return 0;
+    }
+
+    if (!that || !Array.isArray(that)) {
+        return GenericOrder.prototype.compare.call(this, that, compare);
+    }
+
+    length = Math.min(this.length, that.length);
+
+    for (i = 0; i < length; i++) {
+        if (i in this) {
+            if (!(i in that)) {
+                return -1;
+            } else {
+                lhs = this[i];
+                rhs = that[i];
+                relative = compare(lhs, rhs);
+                if (relative) {
+                    return relative;
+                }
+            }
+        } else if (i in that) {
+            return 1;
+        }
+    }
+
+    return this.length - that.length;
+});
+
+define("equals", function (that, equals) {
+    equals = equals || Object.equals;
+    var i = 0;
+    var length = this.length;
+    var left;
+    var right;
+
+    if (this === that) {
+        return true;
+    }
+    if (!that || !Array.isArray(that)) {
+        return GenericOrder.prototype.equals.call(this, that);
+    }
+
+    if (length !== that.length) {
+        return false;
+    } else {
+        for (; i < length; ++i) {
+            if (i in this) {
+                if (!(i in that)) {
+                    return false;
+                }
+                left = this[i];
+                right = that[i];
+                if (!equals(left, right)) {
+                    return false;
+                }
+            } else {
+                if (i in that) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+});
+
+define("clone", function (depth, memo) {
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return this;
+    }
+    memo = memo || new WeakMap();
+    var clone = [];
+    for (var i in this) {
+        if (Object.owns(this, i)) {
+            clone[i] = Object.clone(this[i], depth - 1, memo);
+        }
+    };
+    return clone;
+});
+
+define("iterate", function (start, end) {
+    return new ArrayIterator(this, start, end);
+});
+
+define("Iterator", ArrayIterator);
+
+function ArrayIterator(array, start, end) {
+    this.array = array;
+    this.start = start == null ? 0 : start;
+    this.end = end;
+};
+
+ArrayIterator.prototype.next = function () {
+    if (this.start === (this.end == null ? this.array.length : this.end)) {
+        throw StopIteration;
+    } else {
+        return this.array[this.start++];
+    }
+};
+
+
+},{"./generic-collection":41,"./generic-order":43,"./shim-function":55,"weak-map":52}],55:[function(require,module,exports){
+arguments[4][19][0].apply(exports,arguments)
+},{"dup":19}],56:[function(require,module,exports){
+"use strict";
+
+var WeakMap = require("weak-map");
+
+module.exports = Object;
+
+/*
+    Based in part on extras from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/**
+    Defines extensions to intrinsic <code>Object</code>.
+    @see [Object class]{@link external:Object}
+*/
+
+/**
+    A utility object to avoid unnecessary allocations of an empty object
+    <code>{}</code>.  This object is frozen so it is safe to share.
+
+    @object external:Object.empty
+*/
+Object.empty = Object.freeze(Object.create(null));
+
+/**
+    Returns whether the given value is an object, as opposed to a value.
+    Unboxed numbers, strings, true, false, undefined, and null are not
+    objects.  Arrays are objects.
+
+    @function external:Object.isObject
+    @param {Any} value
+    @returns {Boolean} whether the given value is an object
+*/
+Object.isObject = function (object) {
+    return Object(object) === object;
+};
+
+/**
+    Returns the value of an any value, particularly objects that
+    implement <code>valueOf</code>.
+
+    <p>Note that, unlike the precedent of methods like
+    <code>Object.equals</code> and <code>Object.compare</code> would suggest,
+    this method is named <code>Object.getValueOf</code> instead of
+    <code>valueOf</code>.  This is a delicate issue, but the basis of this
+    decision is that the JavaScript runtime would be far more likely to
+    accidentally call this method with no arguments, assuming that it would
+    return the value of <code>Object</code> itself in various situations,
+    whereas <code>Object.equals(Object, null)</code> protects against this case
+    by noting that <code>Object</code> owns the <code>equals</code> property
+    and therefore does not delegate to it.
+
+    @function external:Object.getValueOf
+    @param {Any} value a value or object wrapping a value
+    @returns {Any} the primitive value of that object, if one exists, or passes
+    the value through
+*/
+Object.getValueOf = function (value) {
+    if (Object.can(value, "valueOf")) {
+        value = value.valueOf();
+    }
+    return value;
+};
+
+var hashMap = new WeakMap();
+Object.hash = function (object) {
+    if (Object.can(object, "hash")) {
+        return "" + object.hash();
+    } else if (Object(object) === object) {
+        if (!hashMap.has(object)) {
+            hashMap.set(object, Math.random().toString(36).slice(2));
+        }
+        return hashMap.get(object);
+    } else {
+        return "" + object;
+    }
+};
+
+/**
+    A shorthand for <code>Object.prototype.hasOwnProperty.call(object,
+    key)</code>.  Returns whether the object owns a property for the given key.
+    It does not consult the prototype chain and works for any string (including
+    "hasOwnProperty") except "__proto__".
+
+    @function external:Object.owns
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object owns a property wfor the given key.
+*/
+var owns = Object.prototype.hasOwnProperty;
+Object.owns = function (object, key) {
+    return owns.call(object, key);
+};
+
+/**
+    Returns whether a value implements a particular duck-type method.
+
+    <p>To qualify as a duck-type method, the value in question must have a
+    method by the given name on the prototype chain.  To distinguish it from
+    a property of an object literal, the property must not be owned by the
+    object directly.
+
+    <p>A value that implements a method is not necessarily an object, for
+    example, numbers implement <code>valueOf</code>, so this is function
+    does not imply <code>Object.isObject</code> of the same value.
+
+    @function external:Object.can
+    @param {Any} value a value
+    @param {String} name a method name
+    @returns {Boolean} whether the given value implements the given method
+
+*/
+Object.can = function (object, name) {
+    return (
+        object != null && // false only for null *and* undefined
+        typeof object[name] === "function" &&
+        !owns.call(object, name)
+    );
+};
+
+/**
+    A utility that is like Object.owns but is also useful for finding
+    properties on the prototype chain, provided that they do not refer to
+    methods on the Object prototype.  Works for all strings except "__proto__".
+
+    <p>Alternately, you could use the "in" operator as long as the object
+    descends from "null" instead of the Object.prototype, as with
+    <code>Object.create(null)</code>.  However,
+    <code>Object.create(null)</code> only works in fully compliant EcmaScript 5
+    JavaScript engines and cannot be faithfully shimmed.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "has", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the instance.
+
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object, or any of its prototypes except
+    <code>Object.prototype</code>
+    @function external:Object.has
+*/
+Object.has = function (object, key) {
+    if (typeof object !== "object") {
+        throw new Error("Object.has can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "has"
+    if (Object.can(object, "has")) {
+        return object.has(key);
+    // otherwise report whether the key is on the prototype chain,
+    // as long as it is not one of the methods on object.prototype
+    } else if (typeof key === "string") {
+        return key in object && object[key] !== Object.prototype[key];
+    } else {
+        throw new Error("Key must be a string for Object.has on plain objects");
+    }
+};
+
+/**
+    Gets the value for a corresponding key from an object.
+
+    <p>Uses Object.has to determine whether there is a corresponding value for
+    the given key.  As such, <code>Object.get</code> is capable of retriving
+    values from the prototype chain as long as they are not from the
+    <code>Object.prototype</code>.
+
+    <p>If there is no corresponding value, returns the given default, which may
+    be <code>undefined</code>.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "get", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the implementation.  For a `Map`,
+    for example, the key might be any object.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value a default to return, <code>undefined</code> if omitted
+    @returns {Any} value for key, or default value
+    @function external:Object.get
+*/
+Object.get = function (object, key, value) {
+    if (typeof object !== "object") {
+        throw new Error("Object.get can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "get"
+    if (Object.can(object, "get")) {
+        return object.get(key, value);
+    } else if (Object.has(object, key)) {
+        return object[key];
+    } else {
+        return value;
+    }
+};
+
+/**
+    Sets the value for a given key on an object.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "set", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  As such,
+    the key domain varies by the object type.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value
+    @returns <code>undefined</code>
+    @function external:Object.set
+*/
+Object.set = function (object, key, value) {
+    if (Object.can(object, "set")) {
+        object.set(key, value);
+    } else {
+        object[key] = value;
+    }
+};
+
+Object.addEach = function (target, source) {
+    if (!source) {
+    } else if (Object.can(source, "forEach")) {
+        // copy map-alikes
+        if (typeof source.keys === "function") {
+            source.forEach(function (value, key) {
+                target[key] = value;
+            });
+        // iterate key value pairs of other iterables
+        } else {
+            source.forEach(function (pair) {
+                target[pair[0]] = pair[1];
+            });
+        }
+    } else {
+        // copy other objects as map-alikes
+        Object.keys(source).forEach(function (key) {
+            target[key] = source[key];
+        });
+    }
+    return target;
+};
+
+/**
+    Iterates over the owned properties of an object.
+
+    @function external:Object.forEach
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+*/
+Object.forEach = function (object, callback, thisp) {
+    Object.keys(object).forEach(function (key) {
+        callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Iterates over the owned properties of a map, constructing a new array of
+    mapped values.
+
+    @function external:Object.map
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+    @returns {Array} the respective values returned by the callback for each
+    item in the object.
+*/
+Object.map = function (object, callback, thisp) {
+    return Object.keys(object).map(function (key) {
+        return callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Returns the values for owned properties of an object.
+
+    @function external:Object.map
+    @param {Object} object
+    @returns {Array} the respective value for each owned property of the
+    object.
+*/
+Object.values = function (object) {
+    return Object.map(object, Function.identity);
+};
+
+// TODO inline document concat
+Object.concat = function () {
+    var object = {};
+    for (var i = 0; i < arguments.length; i++) {
+        Object.addEach(object, arguments[i]);
+    }
+    return object;
+};
+
+Object.from = Object.concat;
+
+/**
+    Returns whether two values are identical.  Any value is identical to itself
+    and only itself.  This is much more restictive than equivalence and subtly
+    different than strict equality, <code>===</code> because of edge cases
+    including negative zero and <code>NaN</code>.  Identity is useful for
+    resolving collisions among keys in a mapping where the domain is any value.
+    This method does not delgate to any method on an object and cannot be
+    overridden.
+    @see http://wiki.ecmascript.org/doku.php?id=harmony:egal
+    @param {Any} this
+    @param {Any} that
+    @returns {Boolean} whether this and that are identical
+    @function external:Object.is
+*/
+Object.is = function (x, y) {
+    if (x === y) {
+        // 0 === -0, but they are not identical
+        return x !== 0 || 1 / x === 1 / y;
+    }
+    // NaN !== NaN, but they are identical.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    return x !== x && y !== y;
+};
+
+/**
+    Performs a polymorphic, type-sensitive deep equivalence comparison of any
+    two values.
+
+    <p>As a basic principle, any value is equivalent to itself (as in
+    identity), any boxed version of itself (as a <code>new Number(10)</code> is
+    to 10), and any deep clone of itself.
+
+    <p>Equivalence has the following properties:
+
+    <ul>
+        <li><strong>polymorphic:</strong>
+            If the given object is an instance of a type that implements a
+            methods named "equals", this function defers to the method.  So,
+            this function can safely compare any values regardless of type,
+            including undefined, null, numbers, strings, any pair of objects
+            where either implements "equals", or object literals that may even
+            contain an "equals" key.
+        <li><strong>type-sensitive:</strong>
+            Incomparable types are not equal.  No object is equivalent to any
+            array.  No string is equal to any other number.
+        <li><strong>deep:</strong>
+            Collections with equivalent content are equivalent, recursively.
+        <li><strong>equivalence:</strong>
+            Identical values and objects are equivalent, but so are collections
+            that contain equivalent content.  Whether order is important varies
+            by type.  For Arrays and lists, order is important.  For Objects,
+            maps, and sets, order is not important.  Boxed objects are mutally
+            equivalent with their unboxed values, by virtue of the standard
+            <code>valueOf</code> method.
+    </ul>
+    @param this
+    @param that
+    @returns {Boolean} whether the values are deeply equivalent
+    @function external:Object.equals
+*/
+Object.equals = function (a, b, equals) {
+    equals = equals || Object.equals;
+    // unbox objects, but do not confuse object literals
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    if (a === b)
+        // 0 === -0, but they are not equal
+        return a !== 0 || 1 / a === 1 / b;
+    if (a === null || b === null)
+        return a === b;
+    if (Object.can(a, "equals"))
+        return a.equals(b, equals);
+    // commutative
+    if (Object.can(b, "equals"))
+        return b.equals(a, equals);
+    if (typeof a === "object" && typeof b === "object") {
+        var aPrototype = Object.getPrototypeOf(a);
+        var bPrototype = Object.getPrototypeOf(b);
+        if (
+            aPrototype === bPrototype && (
+                aPrototype === Object.prototype ||
+                aPrototype === null
+            )
+        ) {
+            for (var key in a) {
+                if (!equals(a[key], b[key])) {
+                    return false;
+                }
+            }
+            for (var key in b) {
+                if (!equals(a[key], b[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    // NaN !== NaN, but they are equal.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    return a !== a && b !== b;
+};
+
+// Because a return value of 0 from a `compare` function  may mean either
+// "equals" or "is incomparable", `equals` cannot be defined in terms of
+// `compare`.  However, `compare` *can* be defined in terms of `equals` and
+// `lessThan`.  Again however, more often it would be desirable to implement
+// all of the comparison functions in terms of compare rather than the other
+// way around.
+
+/**
+    Determines the order in which any two objects should be sorted by returning
+    a number that has an analogous relationship to zero as the left value to
+    the right.  That is, if the left is "less than" the right, the returned
+    value will be "less than" zero, where "less than" may be any other
+    transitive relationship.
+
+    <p>Arrays are compared by the first diverging values, or by length.
+
+    <p>Any two values that are incomparable return zero.  As such,
+    <code>equals</code> should not be implemented with <code>compare</code>
+    since incomparability is indistinguishable from equality.
+
+    <p>Sorts strings lexicographically.  This is not suitable for any
+    particular international setting.  Different locales sort their phone books
+    in very different ways, particularly regarding diacritics and ligatures.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "compare", this function defers to the instance.  The method does not
+    need to be an owned property to distinguish it from an object literal since
+    object literals are incomparable.  Unlike <code>Object</code> however,
+    <code>Array</code> implements <code>compare</code>.
+
+    @param {Any} left
+    @param {Any} right
+    @returns {Number} a value having the same transitive relationship to zero
+    as the left and right values.
+    @function external:Object.compare
+*/
+Object.compare = function (a, b) {
+    // unbox objects, but do not confuse object literals
+    // mercifully handles the Date case
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    var aType = typeof a;
+    var bType = typeof b;
+    if (a === b)
+        return 0;
+    if (aType !== bType)
+        return 0;
+    if (aType === "number")
+        return a - b;
+    if (aType === "string")
+        return a < b ? -1 : 1;
+        // the possibility of equality elimiated above
+    if (Object.can(a, "compare"))
+        return a.compare(b);
+    // not commutative, the relationship is reversed
+    if (Object.can(b, "compare"))
+        return -b.compare(a);
+    return 0;
+};
+
+/**
+    Creates a deep copy of any value.  Values, being immutable, are
+    returned without alternation.  Forwards to <code>clone</code> on
+    objects and arrays.
+
+    @function external:Object.clone
+    @param {Any} value a value to clone
+    @param {Number} depth an optional traversal depth, defaults to infinity.
+    A value of <code>0</code> means to make no clone and return the value
+    directly.
+    @param {Map} memo an optional memo of already visited objects to preserve
+    reference cycles.  The cloned object will have the exact same shape as the
+    original, but no identical objects.  Te map may be later used to associate
+    all objects in the original object graph with their corresponding member of
+    the cloned graph.
+    @returns a copy of the value
+*/
+Object.clone = function (value, depth, memo) {
+    value = Object.getValueOf(value);
+    memo = memo || new WeakMap();
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return value;
+    }
+    if (Object.isObject(value)) {
+        if (!memo.has(value)) {
+            if (Object.can(value, "clone")) {
+                memo.set(value, value.clone(depth, memo));
+            } else {
+                var prototype = Object.getPrototypeOf(value);
+                if (prototype === null || prototype === Object.prototype) {
+                    var clone = Object.create(prototype);
+                    memo.set(value, clone);
+                    for (var key in value) {
+                        clone[key] = Object.clone(value[key], depth - 1, memo);
+                    }
+                } else {
+                    throw new Error("Can't clone " + value);
+                }
+            }
+        }
+        return memo.get(value);
+    }
+    return value;
+};
+
+/**
+    Removes all properties owned by this object making the object suitable for
+    reuse.
+
+    @function external:Object.clear
+    @returns this
+*/
+Object.clear = function (object) {
+    if (Object.can(object, "clear")) {
+        object.clear();
+    } else {
+        var keys = Object.keys(object),
+            i = keys.length;
+        while (i) {
+            i--;
+            delete object[keys[i]];
+        }
+    }
+    return object;
+};
+
+
+},{"weak-map":52}],57:[function(require,module,exports){
+arguments[4][21][0].apply(exports,arguments)
+},{"dup":21}],58:[function(require,module,exports){
+arguments[4][22][0].apply(exports,arguments)
+},{"./shim-array":54,"./shim-function":55,"./shim-object":56,"./shim-regexp":57,"dup":22}],59:[function(require,module,exports){
+"use strict";
+
+module.exports = SortedArray;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+function SortedArray(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedArray)) {
+        return new SortedArray(values, equals, compare, getDefault);
+    }
+    if (Array.isArray(values)) {
+        this.array = values;
+        values = values.splice(0, values.length);
+    } else {
+        this.array = [];
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.getDefault = getDefault || Function.noop;
+
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-array").SortedArray will work in MontageJS
+SortedArray.SortedArray = SortedArray;
+
+Object.addEach(SortedArray.prototype, GenericCollection.prototype);
+Object.addEach(SortedArray.prototype, PropertyChanges.prototype);
+Object.addEach(SortedArray.prototype, RangeChanges.prototype);
+
+function search(array, value, compare) {
+    var first = 0;
+    var last = array.length - 1;
+    while (first <= last) {
+        var middle = (first + last) >> 1; // Math.floor( / 2)
+        var comparison = compare(value, array[middle]);
+        if (comparison > 0) {
+            first = middle + 1;
+        } else if (comparison < 0) {
+            last = middle - 1;
+        } else {
+            return middle;
+        }
+    }
+    return -(first + 1);
+}
+
+function searchFirst(array, value, compare, equals) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -1;
+    } else {
+        while (index > 0 && equals(value, array[index - 1])) {
+            index--;
+        }
+        if (!equals(value, array[index])) {
+            return -1;
+        } else {
+            return index;
+        }
+    }
+}
+
+function searchLast(array, value, compare, equals) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -1;
+    } else {
+        while (index < array.length - 1 && equals(value, array[index + 1])) {
+            index++;
+        }
+        if (!equals(value, array[index])) {
+            return -1;
+        } else {
+            return index;
+        }
+    }
+}
+
+function searchForInsertionIndex(array, value, compare) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -index - 1;
+    } else {
+        var last = array.length - 1;
+        while (index < last && compare(value, array[index + 1]) === 0) {
+            index++;
+        }
+        return index;
+    }
+}
+
+SortedArray.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+
+SortedArray.prototype.has = function (value) {
+    var index = search(this.array, value, this.contentCompare);
+    return index >= 0 && this.contentEquals(this.array[index], value);
+};
+
+SortedArray.prototype.get = function (value) {
+    var index = searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+    if (index !== -1) {
+        return this.array[index];
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+SortedArray.prototype.add = function (value) {
+    var index = searchForInsertionIndex(this.array, value, this.contentCompare);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchBeforeRangeChange([value], [], index);
+    }
+    this.array.splice(index, 0, value);
+    this.length++;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([value], [], index);
+    }
+    return true;
+};
+
+SortedArray.prototype["delete"] = function (value) {
+    var index = searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+    if (index !== -1) {
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([], [value], index);
+        }
+        this.array.splice(index, 1);
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([], [value], index);
+        }
+        return true;
+    } else {
+        return false;
+    }
+};
+
+SortedArray.prototype.indexOf = function (value) {
+    return searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.lastIndexOf = function (value) {
+    return searchLast(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.find = function (value) {
+    return searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.findLast = function (value) {
+    return searchLast(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.push = function () {
+    this.addEach(arguments);
+};
+
+SortedArray.prototype.unshift = function () {
+    this.addEach(arguments);
+};
+
+SortedArray.prototype.pop = function () {
+    return this.array.pop();
+};
+
+SortedArray.prototype.shift = function () {
+    return this.array.shift();
+};
+
+SortedArray.prototype.slice = function () {
+    return this.array.slice.apply(this.array, arguments);
+};
+
+SortedArray.prototype.splice = function (index, length /*...plus*/) {
+    return this.swap(index, length, Array.prototype.slice.call(arguments, 2));
+};
+
+SortedArray.prototype.swap = function (index, length, plus) {
+    if (index === undefined && length === undefined) {
+        return [];
+    }
+    index = index || 0;
+    if (index < 0) {
+        index += this.length;
+    }
+    if (length === undefined) {
+        length = Infinity;
+    }
+    var minus = this.slice(index, index + length);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchBeforeRangeChange(plus, minus, index);
+    }
+    this.array.splice(index, length);
+    this.addEach(plus);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, index);
+    }
+    return minus;
+};
+
+SortedArray.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.array.reduce(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+SortedArray.prototype.reduceRight = function () {
+    var thisp = arguments[2];
+    return this.array.reduceRight(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+SortedArray.prototype.min = function () {
+    if (this.length) {
+        return this.array[0];
+    }
+};
+
+SortedArray.prototype.max = function () {
+    if (this.length) {
+        return this.array[this.length - 1];
+    }
+};
+
+SortedArray.prototype.one = function () {
+    return this.array.one();
+};
+
+SortedArray.prototype.clear = function () {
+    var minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.array.slice();
+        this.dispatchBeforeRangeChange([], minus, 0);
+    }
+    this.length = 0;
+    this.array.clear();
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], minus, 0);
+    }
+};
+
+SortedArray.prototype.equals = function (that, equals) {
+    return this.array.equals(that, equals);
+};
+
+SortedArray.prototype.compare = function (that, compare) {
+    return this.array.compare(that, compare);
+};
+
+SortedArray.prototype.iterate = function (start, end) {
+    return new this.Iterator(this.array, start, end);
+};
+
+SortedArray.prototype.Iterator = Array.prototype.Iterator;
+
+
+},{"./generic-collection":41,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],60:[function(require,module,exports){
+"use strict";
+
+module.exports = SortedSet;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+var TreeLog = require("./tree-log");
+
+function SortedSet(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedSet)) {
+        return new SortedSet(values, equals, compare, getDefault);
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.getDefault = getDefault || Function.noop;
+    this.root = null;
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-set").SortedSet will work in MontageJS
+SortedSet.SortedSet = SortedSet;
+
+Object.addEach(SortedSet.prototype, GenericCollection.prototype);
+Object.addEach(SortedSet.prototype, GenericSet.prototype);
+Object.addEach(SortedSet.prototype, PropertyChanges.prototype);
+Object.addEach(SortedSet.prototype, RangeChanges.prototype);
+
+SortedSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+
+SortedSet.prototype.has = function (value) {
+    if (this.root) {
+        this.splay(value);
+        return this.contentEquals(value, this.root.value);
+    } else {
+        return false;
+    }
+};
+
+SortedSet.prototype.get = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root.value;
+        }
+    }
+    return this.getDefault(value);
+};
+
+SortedSet.prototype.add = function (value) {
+    var node = new this.Node(value);
+    if (this.root) {
+        this.splay(value);
+        if (!this.contentEquals(value, this.root.value)) {
+            var comparison = this.contentCompare(value, this.root.value);
+            if (comparison === 0) {
+                throw new Error("SortedSet cannot contain incomparable but inequal values: " + value + " and " + this.root.value);
+            }
+            if (this.dispatchesRangeChanges) {
+                this.dispatchBeforeRangeChange([value], [], this.root.index);
+            }
+            if (comparison < 0) {
+                // rotate right
+                //   R        N
+                //  / \  ->  / \
+                // l   r    l   R
+                // :   :    :    \
+                //                r
+                //                :
+                node.right = this.root;
+                node.left = this.root.left;
+                this.root.left = null;
+                this.root.touch();
+            } else {
+                // rotate left
+                //   R        N
+                //  / \  ->  / \
+                // l   r    R   r
+                // :   :   /    :
+                //        l
+                //        :
+                node.left = this.root;
+                node.right = this.root.right;
+                this.root.right = null;
+                this.root.touch();
+            }
+            node.touch();
+            this.root = node;
+            this.length++;
+            if (this.dispatchesRangeChanges) {
+                this.dispatchRangeChange([value], [], this.root.index);
+            }
+            return true;
+        }
+    } else {
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([value], [], 0);
+        }
+        this.root = node;
+        this.length++;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([value], [], 0);
+        }
+        return true;
+    }
+    return false;
+};
+
+SortedSet.prototype['delete'] = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            var index = this.root.index;
+            if (this.dispatchesRangeChanges) {
+                this.dispatchBeforeRangeChange([], [value], index);
+            }
+            if (!this.root.left) {
+                this.root = this.root.right;
+            } else {
+                // remove the right side of the tree,
+                var right = this.root.right;
+                this.root = this.root.left;
+                // the tree now only contains the left side of the tree, so all
+                // values are less than the value deleted.
+                // splay so that the root has an empty right child
+                this.splay(value);
+                // put the right side of the tree back
+                this.root.right = right;
+            }
+            this.length--;
+            if (this.root) {
+                this.root.touch();
+            }
+            if (this.dispatchesRangeChanges) {
+                this.dispatchRangeChange([], [value], index);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+SortedSet.prototype.indexOf = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root.index;
+        }
+    }
+    return -1;
+};
+
+SortedSet.prototype.find = function (value) {
+    if (this.root) {
+        this.splay(value);
+        if (this.contentEquals(value, this.root.value)) {
+            return this.root;
+        }
+    }
+};
+
+SortedSet.prototype.findGreatest = function (at) {
+    if (this.root) {
+        at = at || this.root;
+        while (at.right) {
+            at = at.right;
+        }
+        return at;
+    }
+};
+
+SortedSet.prototype.findLeast = function (at) {
+    if (this.root) {
+        at = at || this.root;
+        while (at.left) {
+            at = at.left;
+        }
+        return at;
+    }
+};
+
+SortedSet.prototype.findGreatestLessThanOrEqual = function (value) {
+    if (this.root) {
+        this.splay(value);
+        // assert root.value <= value
+        return this.root;
+    }
+};
+
+SortedSet.prototype.findGreatestLessThan = function (value) {
+    if (this.root) {
+        this.splay(value);
+        // assert root.value <= value
+        return this.root.getPrevious();
+    }
+};
+
+SortedSet.prototype.findLeastGreaterThanOrEqual = function (value) {
+    if (this.root) {
+        this.splay(value);
+        // assert root.value <= value
+        var comparison = this.contentCompare(value, this.root.value);
+        if (comparison === 0) {
+            return this.root;
+        } else {
+            return this.root.getNext();
+        }
+    }
+};
+
+SortedSet.prototype.findLeastGreaterThan = function (value) {
+    if (this.root) {
+        this.splay(value);
+        // assert root.value <= value
+        var comparison = this.contentCompare(value, this.root.value);
+        return this.root.getNext();
+    }
+};
+
+SortedSet.prototype.pop = function () {
+    if (this.root) {
+        var found = this.findGreatest();
+        this["delete"](found.value);
+        return found.value;
+    }
+};
+
+SortedSet.prototype.shift = function () {
+    if (this.root) {
+        var found = this.findLeast();
+        this["delete"](found.value);
+        return found.value;
+    }
+};
+
+SortedSet.prototype.push = function () {
+    this.addEach(arguments);
+};
+
+SortedSet.prototype.unshift = function () {
+    this.addEach(arguments);
+};
+
+SortedSet.prototype.slice = function (start, end) {
+    var temp;
+    start = start || 0;
+    end = end || this.length;
+    if (start < 0) {
+        start += this.length;
+    }
+    if (end < 0) {
+        end += this.length;
+    }
+    var sliced = [];
+    if (this.root) {
+        this.splayIndex(start);
+        while (this.root.index < end) {
+            sliced.push(this.root.value);
+            if (!this.root.right) {
+                break;
+            }
+            this.splay(this.root.getNext().value);
+        }
+    }
+    return sliced;
+};
+
+SortedSet.prototype.splice = function (at, length /*...plus*/) {
+    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
+};
+
+SortedSet.prototype.swap = function (start, length, plus) {
+    if (start === undefined && length === undefined) {
+        return [];
+    }
+    start = start || 0;
+    if (start < 0) {
+        start += this.length;
+    }
+    if (length === undefined) {
+        length = Infinity;
+    }
+    var swapped = [];
+
+    if (this.root) {
+
+        // start
+        this.splayIndex(start);
+
+        // minus length
+        for (var i = 0; i < length; i++) {
+            swapped.push(this.root.value);
+            var next = this.root.getNext();
+            this["delete"](this.root.value);
+            if (!next) {
+                break;
+            }
+            this.splay(next.value);
+        }
+    }
+
+    // plus
+    this.addEach(plus);
+
+    return swapped;
+};
+
+// This is the simplified top-down splaying algorithm from: "Self-adjusting
+// Binary Search Trees" by Sleator and Tarjan guarantees that the root.value <=
+// value if root exists
+// - as described in https://github.com/hij1nx/forest
+SortedSet.prototype.splay = function (value) {
+    var stub, left, right, temp, root, history;
+
+    if (!this.root) {
+        return;
+    }
+
+    // Create a stub node.  The use of the stub node is a bit
+    // counter-intuitive: The right child of the stub node will hold the L tree
+    // of the algorithm.  The left child of the stub node will hold the R tree
+    // of the algorithm.  Using a stub node, left and right will always be
+    // nodes and we avoid special cases.
+    // - http://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/splay-tree-inl.h
+    stub = left = right = new this.Node();
+    // The history is an upside down tree used to propagate new tree sizes back
+    // up the left and right arms of a traversal.  The right children of the
+    // transitive left side of the tree will be former roots while linking
+    // left.  The left children of the transitive walk to the right side of the
+    // history tree will all be previous roots from linking right.  The last
+    // node of the left and right traversal will each become a child of the new
+    // root.
+    history = new this.Node();
+    root = this.root;
+
+    while (true) {
+        var comparison = this.contentCompare(value, root.value);
+        if (comparison < 0) {
+            if (root.left) {
+                if (this.contentCompare(value, root.left.value) < 0) {
+                    // rotate right
+                    //        Root         L(temp)
+                    //      /     \       / \
+                    //     L(temp) R    LL    Root
+                    //    / \                /    \
+                    //  LL   LR            LR      R
+                    temp = root.left;
+                    root.left = temp.right;
+                    root.touch();
+                    temp.right = root;
+                    temp.touch();
+                    root = temp;
+                    if (!root.left) {
+                        break;
+                    }
+                }
+                // remember former root for repropagating length
+                temp = new Node();
+                temp.right = root;
+                temp.left = history.left;
+                history.left = temp;
+                // link left
+                right.left = root;
+                right.touch();
+                right = root;
+                root = root.left;
+            } else {
+                break;
+            }
+        } else if (comparison > 0) {
+            if (root.right) {
+                if (this.contentCompare(value, root.right.value) > 0) {
+                    // rotate left
+                    //        Root         L(temp)
+                    //      /     \       / \
+                    //     L(temp) R    LL    Root
+                    //    / \                /    \
+                    //  LL   LR            LR      R
+                    temp = root.right;
+                    root.right = temp.left;
+                    root.touch();
+                    temp.left = root;
+                    temp.touch();
+                    root = temp;
+                    if (!root.right) {
+                        break;
+                    }
+                }
+                // remember former root for repropagating length
+                temp = new Node();
+                temp.left = root;
+                temp.right = history.right;
+                history.right = temp;
+                // link right
+                left.right = root;
+                left.touch();
+                left = root;
+                root = root.right;
+            } else {
+                break;
+            }
+        } else { // equal or incomparable
+            break;
+        }
+    }
+
+    // reassemble
+    left.right = root.left;
+    left.touch();
+    right.left = root.right;
+    right.touch();
+    root.left = stub.right;
+    root.right = stub.left;
+
+    // propagate new lengths
+    while (history.left) {
+        history.left.right.touch();
+        history.left = history.left.left;
+    }
+    while (history.right) {
+        history.right.left.touch();
+        history.right = history.right.right;
+    }
+    root.touch();
+
+    this.root = root;
+};
+
+// an internal utility for splaying a node based on its index
+SortedSet.prototype.splayIndex = function (index) {
+    if (this.root) {
+        var at = this.root;
+        var atIndex = this.root.index;
+
+        while (atIndex !== index) {
+            if (atIndex > index && at.left) {
+                at = at.left;
+                atIndex -= 1 + (at.right ? at.right.length : 0);
+            } else if (atIndex < index && at.right) {
+                at = at.right;
+                atIndex += 1 + (at.left ? at.left.length : 0);
+            } else {
+                break;
+            }
+        }
+
+        this.splay(at.value);
+
+        return this.root.index === index;
+    }
+    return false;
+};
+
+SortedSet.prototype.reduce = function (callback, basis, thisp) {
+    if (this.root) {
+        basis = this.root.reduce(callback, basis, 0, thisp, this);
+    }
+    return basis;
+};
+
+SortedSet.prototype.reduceRight = function (callback, basis, thisp) {
+    if (this.root) {
+        basis = this.root.reduceRight(callback, basis, this.length - 1, thisp, this);
+    }
+    return basis;
+};
+
+SortedSet.prototype.min = function (at) {
+    var least = this.findLeast(at);
+    if (least) {
+        return least.value;
+    }
+};
+
+SortedSet.prototype.max = function (at) {
+    var greatest = this.findGreatest(at);
+    if (greatest) {
+        return greatest.value;
+    }
+};
+
+SortedSet.prototype.one = function () {
+    return this.min();
+};
+
+SortedSet.prototype.clear = function () {
+    var minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.toArray();
+        this.dispatchBeforeRangeChange([], minus, 0);
+    }
+    this.root = null;
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], minus, 0);
+    }
+};
+
+SortedSet.prototype.iterate = function (start, end) {
+    return new this.Iterator(this, start, end);
+};
+
+SortedSet.prototype.Iterator = Iterator;
+
+SortedSet.prototype.summary = function () {
+    if (this.root) {
+        return this.root.summary();
+    } else {
+        return "()";
+    }
+};
+
+SortedSet.prototype.log = function (charmap, logNode, callback, thisp) {
+    charmap = charmap || TreeLog.unicodeRound;
+    logNode = logNode || this.logNode;
+    if (!callback) {
+        callback = console.log;
+        thisp = console;
+    }
+    callback = callback.bind(thisp);
+    if (this.root) {
+        this.root.log(charmap, logNode, callback, callback);
+    }
+};
+
+SortedSet.prototype.logNode = function (node, log, logBefore) {
+    log(" " + node.value);
+};
+
+SortedSet.logCharsets = TreeLog;
+
+SortedSet.prototype.Node = Node;
+
+function Node(value) {
+    this.value = value;
+    this.left = null;
+    this.right = null;
+    this.length = 1;
+}
+
+// TODO case where no basis is provided for reduction
+
+Node.prototype.reduce = function (callback, basis, index, thisp, tree, depth) {
+    depth = depth || 0;
+    if (this.left) {
+        // prerecord length to be resistant to mutation
+        var length = this.left.length;
+        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
+        index += length;
+    }
+    basis = callback.call(thisp, basis, this.value, index, tree, this, depth);
+    index += 1;
+    if (this.right) {
+        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
+    }
+    return basis;
+};
+
+Node.prototype.reduceRight = function (callback, basis, index, thisp, tree, depth) {
+    depth = depth || 0;
+    if (this.right) {
+        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
+        index -= this.right.length;
+    }
+    basis = callback.call(thisp, basis, this.value, this.value, tree, this, depth);
+    index -= 1;
+    if (this.left) {
+        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
+    }
+    return basis;
+};
+
+Node.prototype.touch = function () {
+    this.length = 1 +
+        (this.left ? this.left.length : 0) +
+        (this.right ? this.right.length : 0);
+    this.index = this.left ? this.left.length : 0;
+};
+
+Node.prototype.checkIntegrity = function () {
+    var length = 1;
+    length += this.left ? this.left.checkIntegrity() : 0;
+    length += this.right ? this.right.checkIntegrity() : 0;
+    if (this.length !== length)
+        throw new Error("Integrity check failed: " + this.summary());
+    return length;
+}
+
+// get the next node in this subtree
+Node.prototype.getNext = function () {
+    var node = this;
+    if (node.right) {
+        node = node.right;
+        while (node.left) {
+            node = node.left;
+        }
+        return node;
+    }
+};
+
+// get the previous node in this subtree
+Node.prototype.getPrevious = function () {
+    var node = this;
+    if (node.left) {
+        node = node.left;
+        while (node.right) {
+            node = node.right;
+        }
+        return node;
+    }
+};
+
+Node.prototype.summary = function () {
+    var value = this.value || "-";
+    value += " <" + this.length;
+    if (!this.left && !this.right) {
+        return "(" + value + ")";
+    }
+    return "(" + value + " " + (
+        this.left ? this.left.summary() : "()"
+    ) + ", " + (
+        this.right ? this.right.summary() : "()"
+    ) + ")";
+};
+
+Node.prototype.log = function (charmap, logNode, log, logAbove) {
+    var self = this;
+
+    var branch;
+    if (this.left && this.right) {
+        branch = charmap.intersection;
+    } else if (this.left) {
+        branch = charmap.branchUp;
+    } else if (this.right) {
+        branch = charmap.branchDown;
+    } else {
+        branch = charmap.through;
+    }
+
+    var loggedAbove;
+    this.left && this.left.log(
+        charmap,
+        logNode,
+        function innerWrite(line) {
+            if (!loggedAbove) {
+                loggedAbove = true;
+                // leader
+                logAbove(charmap.fromBelow + charmap.through + line);
+            } else {
+                // below
+                logAbove(charmap.strafe + " " + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            // above
+            logAbove("  " + line);
+        }
+    );
+
+    var loggedOn;
+    logNode(
+        this,
+        function innerWrite(line) {
+            if (!loggedOn) {
+                loggedOn = true;
+                log(branch + line);
+            } else {
+                log((self.right ? charmap.strafe : " ") + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            logAbove((self.left ? charmap.strafe : " ") + line);
+        }
+    );
+
+    var loggedBelow;
+    this.right && this.right.log(
+        charmap,
+        logNode,
+        function innerWrite(line) {
+            if (!loggedBelow) {
+                loggedBelow = true;
+                log(charmap.fromAbove + charmap.through + line);
+            } else {
+                log("  " + line);
+            }
+        },
+        function innerWriteAbove(line) {
+            log(charmap.strafe + " " + line);
+        }
+    );
+};
+
+function Iterator(set, start, end) {
+    this.set = set;
+    this.prev = null;
+    this.end = end;
+    if (start) {
+        var next = this.set.findLeastGreaterThanOrEqual(start);
+        if (next) {
+            this.set.splay(next.value);
+            this.prev = next.getPrevious();
+        }
+    }
+}
+
+Iterator.prototype.next = function () {
+    var next;
+    if (this.prev) {
+        next = this.set.findLeastGreaterThan(this.prev.value);
+    } else {
+        next = this.set.findLeast();
+    }
+    if (!next) {
+        throw StopIteration;
+    }
+    if (
+        this.end !== undefined &&
+        this.set.contentCompare(next.value, this.end) >= 0
+    ) {
+        throw StopIteration;
+    }
+    this.prev = next;
+    return next.value;
+};
+
+
+},{"./generic-collection":41,"./generic-set":44,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58,"./tree-log":61}],61:[function(require,module,exports){
+arguments[4][24][0].apply(exports,arguments)
+},{"dup":24}],62:[function(require,module,exports){
+
+var parse = require("./parse");
+var compile = require("./compile-observer");
+var Observers = require("./observers");
+var autoCancelPrevious = Observers.autoCancelPrevious;
+var Scope = require("./scope");
+
+module.exports = observe;
+function observe(source, expression, descriptorOrFunction) {
+    var descriptor;
+    if (typeof descriptorOrFunction === "function") {
+        descriptor = {change: descriptorOrFunction};
+    } else {
+        descriptor = descriptorOrFunction;
+    }
+
+    descriptor = descriptor || empty;
+    descriptor.source = source;
+    descriptor.sourcePath = expression;
+    var parameters = descriptor.parameters = descriptor.parameters || source;
+    var document = descriptor.document;
+    var components = descriptor.components;
+    var beforeChange = descriptor.beforeChange;
+    var contentChange = descriptor.contentChange;
+
+    // TODO consider the possibility that source has an intrinsic scope
+    // property
+    var sourceScope = new Scope(source);
+    sourceScope.parameters = parameters;
+    sourceScope.document = document;
+    sourceScope.components = components;
+    sourceScope.beforeChange = beforeChange;
+
+    var syntax = parse(expression);
+    var observe = compile(syntax);
+
+    // decorate for content change observations
+    if (contentChange === true) {
+        observe = Observers.makeRangeContentObserver(observe);
+    }
+
+    return observe(autoCancelPrevious(function (value) {
+        if (!value) {
+        } else if (typeof contentChange !== "function") {
+            return descriptor.change.apply(source, arguments);
+        } else if (typeof contentChange === "function") {
+            value.addRangeChangeListener(contentChange);
+            return function () {
+                value.removeRangeChangeListener(contentChange);
+            };
+        }
+    }), sourceScope);
+}
+
+var empty = {};
+
+
+},{"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66}],63:[function(require,module,exports){
+
+require("collections/shim"); // Function.noop
+var PropertyChanges = require("collections/listen/property-changes");
+require("collections/listen/array-changes");
+var SortedArray = require("collections/sorted-array");
+var SortedSet = require("collections/sorted-set");
+var Map = require("collections/map");
+var Set = require("collections/set");
+var Heap = require("collections/heap");
+var Scope = require("./scope");
+var Operators = require("./operators");
+
+// Simple stuff..."degenerate" even
+
+exports.makeLiteralObserver = makeLiteralObserver;
+function makeLiteralObserver(literal) {
+    return function observeLiteral(emit) {
+        return emit(literal);
+    };
+}
+
+exports.observeValue = observeValue;
+function observeValue(emit, scope) {
+    return emit(scope.value);
+}
+
+exports.observeParameters = observeParameters;
+function observeParameters(emit, scope) {
+    return emit(scope.parameters);
+}
+
+// This is a concession that in practice FRB may be used in conjunction with a
+// browser DOM.
+exports.makeElementObserver = makeElementObserver;
+function makeElementObserver(id) {
+    return function observeElement(emit, scope) {
+        return emit(scope.document.getElementById(id));
+    };
+}
+
+// This is a concession that in practice FRB will probably be used mostly in
+// conjunction with MontageJS for its component model.
+exports.makeComponentObserver = makeComponentObserver;
+function makeComponentObserver(label, syntax) {
+    return function observeComponent(emit, scope) {
+        // TODO error if scope.components does not exist or components for
+        // label does not exist
+        var components = scope.components;
+        var method = components.getObjectByLabel || components.getComponentByLabel;
+        var component = method.call(components, label);
+        syntax.component = component;
+        return emit(component);
+    };
+}
+
+exports.observeProperty = observeProperty;
+var _observeProperty = observeProperty; // to bypass scope shadowing problems below
+function observeProperty(object, key, emit, scope) {
+    if (object == null) return emit();
+    var cancel = Function.noop;
+    function propertyChange(value, key, object) {
+        cancel();
+        cancel = emit(value, key, object) || Function.noop;
+    }
+    PropertyChanges.addOwnPropertyChangeListener(
+        object,
+        key,
+        propertyChange,
+        scope.beforeChange
+    );
+    propertyChange(object[key], key, object);
+    return function cancelPropertyObserver() {
+        cancel();
+        PropertyChanges.removeOwnPropertyChangeListener(
+            object,
+            key,
+            propertyChange,
+            scope.beforeChange
+        );
+    };
+}
+
+exports.makePropertyObserver = makePropertyObserver;
+function makePropertyObserver(observeObject, observeKey) {
+    return function observeProperty(emit, scope) {
+        return observeKey(function replaceKey(key) {
+            if (typeof key !== "string" && typeof key !== "number") return emit();
+            return observeObject(function replaceObject(object) {
+                if (object == null) return emit();
+                if (object.observeProperty) {
+                    return object.observeProperty(key, emit, scope);
+                } else {
+                    return _observeProperty(object, key, emit, scope);
+                }
+            }, scope);
+        }, scope);
+    };
+}
+
+exports.observeKey = observeGet; // deprecated
+exports.observeGet = observeGet;
+var _observeGet = observeGet; // to bypass scope shadowing below
+function observeGet(collection, key, emit, scope) {
+    var cancel = Function.noop;
+    var equals = collection.contentEquals || Object.equals;
+    function mapChange(value, mapKey, collection) {
+        if (equals(key, mapKey)) {
+            cancel();
+            cancel = emit(value, key, collection) || Function.noop;
+        }
+    }
+    mapChange(collection.get(key), key, collection);
+    collection.addMapChangeListener(mapChange, scope.beforeChange);
+    return function cancelMapObserver() {
+        cancel();
+        collection.removeMapChangeListener(mapChange);
+    };
+}
+
+exports.makeGetObserver = makeGetObserver;
+function makeGetObserver(observeCollection, observeKey) {
+    return function observeGet(emit, scope) {
+        return observeCollection(function replaceCollection(collection) {
+            if (!collection) return emit();
+            return observeKey(function replaceKey(key) {
+                if (key == null) return emit();
+                if (collection.observeGet) {
+                    // polymorphic override
+                    return collection.observeGet(key, emit, scope);
+                } else {
+                    // common case
+                    return _observeGet(collection, key, emit, scope);
+                }
+            }, scope);
+        }, scope);
+    };
+}
+
+exports.makeHasObserver = makeHasObserver;
+function makeHasObserver(observeSet, observeValue) {
+    return function observeHas(emit, scope) {
+        emit = makeUniq(emit);
+        return observeValue(function replaceValue(sought) {
+            return observeSet(function replaceSet(set) {
+                if (!set) return emit();
+                return observeRangeChange(set, function rangeChange() {
+                    // this could be done incrementally if there were guarantees of
+                    // uniqueness, but if there are guarantees of uniqueness, the
+                    // data structure can probably efficiently check
+                    return emit((set.has || set.contains).call(set, sought));
+                }, scope);
+            }, scope);
+        }, scope);
+    };
+}
+
+
+// Compound Observers
+
+// accepts an array of observers and emits an array of the corresponding
+// values, incrementally updated
+exports.makeObserversObserver = makeObserversObserver;
+function makeObserversObserver(observers) {
+    return function observeObservers(emit, scope) {
+        var output = Array(observers.length);
+        for (var i = 0; i < observers.length; i++) {
+            output[i] = undefined; // pevent sparse/holes
+        }
+        var cancelers = observers.map(function observeObserver(observe, index) {
+            return observe(function replaceValue(value) {
+                output.set(index, value);
+            }, scope);
+        });
+        var cancel = emit(output) || Function.noop;
+        return function cancelObserversObserver() {
+            cancel();
+            cancelEach(cancelers);
+        };
+    };
+}
+
+// {type: "record", args: {key: observe}}
+// {a: 10, b: c + d}
+// {type: "record", args: {a: {type: "literal", value: 10 ...
+exports.makeRecordObserver = makeObjectObserver; // deprecated
+exports.makeObjectObserver = makeObjectObserver;
+function makeObjectObserver(observers) {
+    return function observeObject(emit, scope) {
+        var cancelers = {};
+        var output = {};
+        for (var name in observers) {
+            (function (name, observe) {
+                cancelers[name] = observe(function (value) {
+                    output[name] = value;
+                }, scope);
+            })(name, observers[name]);
+        }
+        var cancel = emit(output) || Function.noop;
+        return function cancelRecordObserver() {
+            cancel();
+            for (var name in cancelers) {
+                cancelers[name]();
+            }
+        };
+    };
+}
+
+exports.makeTupleObserver = makeArrayObserver; // deprecated
+exports.makeArrayObserver = makeArrayObserver;
+function makeArrayObserver() {
+    return makeObserversObserver(Array.prototype.slice.call(arguments));
+}
+
+// Operators
+
+exports.makeOperatorObserverMaker = makeOperatorObserverMaker;
+function makeOperatorObserverMaker(operator) {
+    return function makeOperatorObserver(/*...observers*/) {
+        var observeOperands = makeObserversObserver(Array.prototype.slice.call(arguments));
+        var observeOperandChanges = makeRangeContentObserver(observeOperands);
+        return function observeOperator(emit, scope) {
+            return observeOperandChanges(function (operands) {
+                if (!operands.every(Operators.defined)) return emit();
+                return emit(operator.apply(void 0, operands));
+            }, scope);
+        };
+    };
+}
+
+exports.makeMethodObserverMaker = makeMethodObserverMaker;
+function makeMethodObserverMaker(name) {
+    var capitalName = name.slice(0, 1).toUpperCase() + name.slice(1);
+    var makeObserverName = 'make' + capitalName + 'Observer';
+    var observeName = 'observe' + capitalName;
+    return function makeMethodObserver(/*...observers*/) {
+        var observeObject = arguments[0];
+        var operandObservers = Array.prototype.slice.call(arguments, 1);
+        var observeOperands = makeObserversObserver(operandObservers);
+        var observeOperandChanges = makeRangeContentObserver(observeOperands);
+        return function observeMethod(emit, scope) {
+            return observeObject(function (object) {
+                if (!object) return emit();
+                if (object[makeObserverName])
+                    return object[makeObserverName].apply(object, operandObservers)(emit, scope);
+                if (object[observeName])
+                    return object[observeName](emit, scope);
+                return observeOperandChanges(function (operands) {
+                    if (!operands.every(Operators.defined)) return emit();
+                    if (typeof object[name] === "function") {
+                        return emit(object[name].apply(object, operands));
+                    } else {
+                        return emit();
+                    }
+                }, scope);
+            }, scope);
+        };
+    };
+}
+
+// The "not" operator coerces null and undefined, so it is not adequate to
+// implement it with makeOperatorObserverMaker.
+
+exports.makeNotObserver = makeNotObserver;
+function makeNotObserver(observeValue) {
+    return function observeNot(emit, scope) {
+        return observeValue(function replaceValue(value) {
+            return emit(!value);
+        }, scope);
+    };
+}
+
+// The "and" and "or" operators short-circuit, so it is not adequate to
+// implement them with makeOperatorObserverMaker.
+
+exports.makeAndObserver = makeAndObserver;
+function makeAndObserver(observeLeft, observeRight) {
+    return function observeAnd(emit, scope) {
+        return observeLeft(function replaceLeft(left) {
+            if (!left) {
+                return emit(left);
+            } else {
+                return observeRight(emit, scope);
+            }
+        }, scope);
+    };
+}
+
+exports.makeOrObserver = makeOrObserver;
+function makeOrObserver(observeLeft, observeRight) {
+    return function observeOr(emit, scope) {
+        return observeLeft(function replaceLeft(left) {
+            if (left) {
+                return emit(left);
+            } else {
+                return observeRight(emit, scope);
+            }
+        }, scope);
+    };
+}
+
+// expression: condition ? consequent : alternate
+// syntax: {type: "if", args: [condition, consequent, alternate]}
+exports.makeConditionalObserver = makeConditionalObserver;
+function makeConditionalObserver(observeCondition, observeConsequent, observeAlternate) {
+    return function observeConditional(emit, scope) {
+        return observeCondition(function replaceCondition(condition) {
+            if (condition == null) {
+                return emit();
+            } else if (condition) {
+                return observeConsequent(emit, scope);
+            } else {
+                return observeAlternate(emit, scope);
+            }
+        }, scope);
+    };
+}
+
+// This cannot be written in terms of the defined operator because the input
+// may be null or undefined and still emit a value.
+exports.makeDefinedObserver = makeDefinedObserver;
+function makeDefinedObserver(observeValue) {
+    return function observeDefault(emit, scope) {
+        return observeValue(function replaceValue(value) {
+            return emit(value != null);
+        }, scope);
+    };
+}
+
+exports.makeDefaultObserver = makeDefaultObserver;
+function makeDefaultObserver(observeValue, observeAlternate) {
+    return function observeDefault(emit, scope) {
+        return observeValue(function replaceValue(value) {
+            if (value == null) {
+                return observeAlternate(emit, scope);
+            } else {
+                return emit(value);
+            }
+        }, scope);
+    };
+}
+
+// Comprehension Observers
+
+// The map comprehension
+// object.array.map{+1}
+// Handles both range content changes and full replacement of the input
+// object.array.splice(0, 1, 2);
+// object.array = [1, 2, 3]
+var makeMapBlockObserver = exports.makeMapBlockObserver = makeNonReplacing(makeReplacingMapBlockObserver);
+function makeReplacingMapBlockObserver(observeCollection, observeRelation) {
+    return function observeMap(emit, scope) {
+        return observeCollection(function replaceMapInput(input) {
+            if (!input) return emit();
+
+            var output = [];
+            var indexRefs = [];
+            var cancelers = [];
+
+            function update(index) {
+                for (; index < input.length; index++) {
+                    indexRefs[index].index = index;
+                }
+            }
+
+            function rangeChange(plus, minus, index) {
+                indexRefs.swap(index, minus.length, plus.map(function (value, offset) {
+                    return {index: index + offset};
+                }));
+                update(index + plus.length);
+                var initialized;
+                var initial = [];
+                cancelEach(cancelers.swap(index, minus.length, plus.map(function (value, offset) {
+                    var indexRef = indexRefs[index + offset];
+                    return observeRelation(function replaceRelationOutput(value) {
+                        if (initialized) {
+                            output.set(indexRef.index, value);
+                        } else {
+                            // It is unnecessary to use .set() because initial
+                            // does not dispatch changes.
+                            initial[offset] = value;
+                        }
+                    }, scope.nest(value));
+                })));
+                initialized = true;
+                output.swap(index, minus.length, initial);
+            }
+
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            // passing the input as a second argument is a special feature of a
+            // mapping observer, utilized by filter observers
+            var cancel = emit(output, input) || Function.noop;
+
+            return function cancelMapObserver() {
+                cancel();
+                cancelEach(cancelers);
+                cancelRangeChange();
+            };
+        }, scope);
+    };
+}
+
+var makeFilterBlockObserver = exports.makeFilterBlockObserver = makeNonReplacing(makeReplacingFilterBlockObserver);
+function makeReplacingFilterBlockObserver(observeCollection, observePredicate) {
+    var observePredicates = makeReplacingMapBlockObserver(observeCollection, observePredicate);
+    return function observeFilter(emit, scope) {
+        return observePredicates(function (predicates, input) {
+            if (!input) return emit();
+
+            var output = [];
+            var cancelers = [];
+            var cumulativeLengths = [0];
+
+            function update(index) {
+                for (; index < predicates.length; index++) {
+                    cumulativeLengths[index + 1] = cumulativeLengths[index] + !!predicates[index];
+                }
+            }
+
+            function rangeChange(plusPredicates, minusPredicates, index) {
+                var plusValues = input.slice(index, index + plusPredicates.length);
+                var minusLength = minusPredicates.map(Boolean).sum();
+                var plusOutput = plusValues.filter(function (value, offset) {
+                    return plusPredicates[offset];
+                });
+                var start = cumulativeLengths[index];
+                var minusOutput = output.slice(start, start + minusLength);
+                // avoid propagating a range change if the output would not be
+                // changed
+                if (
+                    minusOutput.length !== plusOutput.length ||
+                    minusOutput.some(function (value, offset) {
+                        return value !== plusOutput[offset];
+                    })
+                ) {
+                    output.swap(start, minusLength, plusOutput);
+                }
+                update(start);
+            }
+
+            var cancelRangeChange = observeRangeChange(predicates, rangeChange, scope);
+            var cancel = emit(output) || Function.noop;
+            return function cancelFilterObserver() {
+                cancel();
+                cancelEach(cancelers);
+                cancelRangeChange();
+            };
+
+        }, scope);
+    };
+}
+
+// Schwartzian transform / decorate undecorate pattern
+// entries.sorted{key}
+exports.makeSortedBlockObserver = makeSortedBlockObserver;
+function makeSortedBlockObserver(observeCollection, observeRelation) {
+    // produces: [this, key]
+    var observeRelationEntry = makeRelationEntryObserver(observeRelation);
+    // produces: map{[this, key])
+    var observeRelationEntries = makeReplacingMapBlockObserver(observeCollection, observeRelationEntry);
+    var observeSort = function (emit, scope) {
+        return observeRelationEntries(function (input) {
+            // [[value, relatedValue], ...]
+            if (!input) return emit();
+            var output = [];
+            var sorted = SortedArray(output, entryValueEquals, entryValueCompare);
+            function rangeChange(plus, minus) {
+                sorted.deleteEach(minus);
+                sorted.addEach(plus);
+            }
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancel = emit(output) || Function.noop;
+            return function cancelSortedObserver() {
+                cancel();
+                cancelRangeChange();
+            };
+        }, scope);
+    };
+    return makeMapBlockObserver(observeSort, observeEntryKey);
+}
+
+function entryValueEquals(x, y) {
+    return Object.equals(x[1], y[1]);
+}
+
+function entryValueCompare(x, y) {
+    return Object.compare(x[1], y[1]);
+}
+
+// Transforms a value into a [value, relation(value)] tuple
+function makeRelationEntryObserver(observeRelation) {
+    return function observeRelationEntry(emit, scope) {
+        return observeRelation(function replaceRelation(value) {
+            return emit([scope.value, value]);
+        }, scope);
+    };
+}
+
+exports.makeSortedSetBlockObserver = makeSortedSetBlockObserver;
+function makeSortedSetBlockObserver(observeCollection, observeRelation) {
+    var observeRelationEntry = makeRelationEntryObserver(observeRelation);
+    var observeRelationEntries = makeReplacingMapBlockObserver(observeCollection, observeRelationEntry);
+    var observeRelationEntryGroups = makeGroupBlockObserver(observeRelationEntries, observeEntryValue);
+    var observeUniqueRelationEntries = makeReplacingMapBlockObserver(observeRelationEntryGroups, makeLastObserver(observeEntryValue));
+    return function observeSortedSetBlock(emit, scope) {
+        var order = new Map();
+        function compare(x, y) {
+            x = order.get(x);
+            y = order.get(y);
+            return Object.compare(x, y);
+        }
+        function equals(x, y) {
+            x = order.get(x);
+            y = order.get(y);
+            return Object.equals(x, y);
+        }
+        var sortedSet = new SortedSet(null, equals, compare);
+        var cancel = emit(sortedSet) || Function.noop;
+        function rangeChange(plus, minus) {
+            minus.forEach(function (entry) {
+                sortedSet["delete"](entry[0]);
+                order["delete"](entry[0]);
+            });
+            plus.forEach(function (entry) {
+                order.set(entry[0], entry[1]);
+                sortedSet.add(entry[0]);
+            });
+        }
+        function entriesChange(entries) {
+            sortedSet.clear();
+            return observeRangeChange(entries, rangeChange, scope);
+        }
+        var cancelUniqueValuesObserver = observeUniqueRelationEntries(entriesChange, scope);
+        return function cancelSortedSetObserver() {
+            cancel();
+            cancelUniqueValuesObserver();
+        };
+    };
+}
+
+// calculating the reflected index for an incremental change:
+// [0, 1, 2, 3]  length 4
+//     -------  -4 (1+3)
+// --------    0-  (outer.length - index - inner.length)
+exports.makeReversedObserver = makeNonReplacing(makeReplacingReversedObserver);
+function makeReplacingReversedObserver(observeArray) {
+    return function observeReversed(emit, scope) {
+        return observeArray(function (input) {
+            if (!input) return emit();
+            var output = [];
+            function rangeChange(plus, minus, index) {
+                var reflected = output.length - index - minus.length;
+                output.swap(reflected, minus.length, plus.reversed());
+            }
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancel = emit(output);
+            return function cancelReversedObserver() {
+                cancel();
+                cancelRangeChange();
+            };
+        }, scope);
+    };
+}
+
+var makeFlattenObserver =
+exports.makeFlattenObserver = makeNonReplacing(makeReplacingFlattenObserver);
+function makeReplacingFlattenObserver(observeArray) {
+    return function (emit, scope) {
+        return observeArray(function (input) {
+            if (!input) return emit();
+
+            var output = [];
+            var cancelers = [];
+            var cumulativeLengths = [0];
+            var indexRefs = [];
+
+            function update(i) {
+                for (var j = i; j < input.length; j++) {
+                    indexRefs[j].index = j;
+                    if (input[j]) {
+                        cumulativeLengths[j + 1] = cumulativeLengths[j] + input[j].length;
+                    } else {
+                        cumulativeLengths[j + 1] = cumulativeLengths[j];
+                    }
+                }
+            }
+
+            function rangeChange(plus, minus, i) {
+
+                // minus
+                var start = cumulativeLengths[i];
+                var end = cumulativeLengths[i + minus.length];
+                var length = end - start;
+                output.swap(start, length, []);
+
+                indexRefs.swap(i, minus.length, plus.map(function () {
+                    return {index: null};
+                }));
+                update(i);
+
+                // plus
+                cancelEach(cancelers.swap(
+                    i,
+                    minus.length,
+                    plus.map(function (inner, j) {
+                        var index = indexRefs[i + j];
+                        function innerRangeChange(plus, minus, k) {
+                            update(index.index);
+                            var start = cumulativeLengths[index.index] + k;
+                            var end = cumulativeLengths[index.index] + k + minus.length;
+                            var length = end - start;
+                            output.swap(start, length, plus);
+                        }
+                        return observeRangeChange(inner, innerRangeChange, scope);
+                    })
+                ));
+
+            }
+
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancel = emit(output) || Function.noop;
+
+            return function cancelFlattenObserver() {
+                cancel();
+                cancelEach(cancelers);
+                cancelRangeChange();
+            };
+        }, scope);
+    };
+}
+
+exports.makeConcatObserver = makeConcatObserver;
+function makeConcatObserver() {
+    return makeFlattenObserver(
+        makeObserversObserver(
+            Array.prototype.slice.call(arguments)
+        )
+    );
+}
+
+exports.makeSomeBlockObserver = makeSomeBlockObserver;
+function makeSomeBlockObserver(observeCollection, observePredicate) {
+    // collection.some{predicate} is equivalent to
+    // collection.filter{predicate}.length !== 0
+    var observeFilter = makeFilterBlockObserver(observeCollection, observePredicate);
+    var observeLength = makePropertyObserver(observeFilter, observeLengthLiteral);
+    return makeConverterObserver(observeLength, Boolean);
+}
+
+exports.makeEveryBlockObserver = makeEveryBlockObserver;
+function makeEveryBlockObserver(observeCollection, observePredicate) {
+    // collection.every{predicate} is equivalent to
+    // collection.filter{!predicate}.length === 0
+    var observeNotPredicate = makeConverterObserver(observePredicate, Operators.not);
+    var observeFilter = makeFilterBlockObserver(observeCollection, observeNotPredicate);
+    var observeLength = makePropertyObserver(observeFilter, observeLengthLiteral);
+    return makeConverterObserver(observeLength, Operators.not);
+}
+
+// JavaScript (with shims from Collections): names.group(function (x) {return x[0]}) ->
+// names.group{.0} -> [[klass, [...values]], [...], [...]]
+// names.groupMap{.0}.entries()
+exports.makeGroupBlockObserver = makeGroupBlockObserver;
+function makeGroupBlockObserver(observeCollection, observeRelation) {
+    var observeGroup = makeGroupMapBlockObserver(observeCollection, observeRelation);
+    return makeEntriesObserver(observeGroup);
+}
+
+exports.makeGroupMapBlockObserver = makeGroupMapBlockObserver;
+function makeGroupMapBlockObserver(observeCollection, observeRelation) {
+    var observeRelationEntry = makeRelationEntryObserver(observeRelation);
+    var observeRelationEntries = makeReplacingMapBlockObserver(observeCollection, observeRelationEntry);
+    return function observeGroup(emit, scope) {
+        return observeRelationEntries(function (input, original) {
+            if (!input) return emit();
+
+            var groups = Map();
+
+            function rangeChange(plus, minus, index) {
+                minus.forEach(function (item) {
+                    // ASSERT groups.has(item[1]);
+                    var group = groups.get(item[1]);
+                    if (group.length === 1) {
+                        groups["delete"](item[1]);
+                    } else {
+                        group["delete"](item[0]);
+                    }
+                });
+                plus.forEach(function (item) {
+                    var create = !groups.has(item[1]);
+                    var group;
+                    if (create) {
+                        // constructClone ensures that the equivalence classes
+                        // are the same type as the input.  It is shimmed on
+                        // Array by Collections, and supported by all others.
+                        group = original.constructClone();
+                    } else {
+                        group = groups.get(item[1]);
+                    }
+                    group.add(item[0]);
+                    if (create) {
+                        groups.set(item[1], group);
+                    }
+                });
+            }
+
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancel = emit(groups) || Function.noop;
+            return function cancelGroupObserver() {
+                cancelRangeChange();
+                cancel();
+            };
+        }, scope);
+    };
+}
+
+function makeHeapBlockObserver(observeCollection, observeRelation, order) {
+    var observeRelationEntry = makeRelationEntryObserver(observeRelation);
+    var observeRelationEntries = makeReplacingMapBlockObserver(observeCollection, observeRelationEntry);
+
+    function entryValueOrderCompare(a, b) {
+        return Object.compare(a[1], b[1]) * order;
+    }
+
+    return function observeHeapBlock(emit, scope) {
+
+        return observeRelationEntries(function (input) {
+            if (!input) return emit();
+
+            var heap = new Heap(null, entryValueEquals, entryValueOrderCompare);
+
+            function rangeChange(plus, minus) {
+                heap.addEach(plus);
+                heap.deleteEach(minus);
+            }
+
+            function heapChange(item, key) {
+                if (key === 0) {
+                    if (!item) {
+                        return emit();
+                    } else {
+                        return emit(item[0]);
+                    }
+                }
+            }
+
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancelHeapChange = observeMapChange(heap, heapChange, scope);
+
+            return function cancelHeapObserver() {
+                cancelRangeChange();
+                cancelHeapChange();
+            };
+        }, scope);
+    };
+}
+
+exports.makeMaxBlockObserver = makeMaxBlockObserver;
+function makeMaxBlockObserver(observeCollection, observeRelation) {
+    return makeHeapBlockObserver(observeCollection, observeRelation, 1);
+}
+
+// values.min{x}
+exports.makeMinBlockObserver = makeMinBlockObserver;
+function makeMinBlockObserver(observeCollection, observeRelation) {
+    return makeHeapBlockObserver(observeCollection, observeRelation, -1);
+}
+
+exports.makeMaxObserver = makeMaxObserver;
+function makeMaxObserver(observeCollection) {
+    return makeHeapBlockObserver(observeCollection, observeValue, 1);
+}
+
+exports.makeMinObserver = makeMinObserver;
+function makeMinObserver(observeCollection) {
+    return makeHeapBlockObserver(observeCollection, observeValue, -1);
+}
+
+// used by both some and every blocks
+var observeLengthLiteral = makeLiteralObserver("length");
+
+// A utility for generating sum and average observers since they both need to
+// capture some internal state on intiailization, and update that state on
+// range changes.
+function makeCollectionObserverMaker(setup) {
+    return function (observeCollection) {
+        return function (emit, scope) {
+            emit = makeUniq(emit);
+            return observeCollection(function (collection) {
+                if (!collection) return emit();
+                var rangeChange = setup(collection, emit);
+                return observeRangeChange(collection, function (plus, minus, index) {
+                    return emit(rangeChange(plus, minus, index));
+                }, scope);
+            }, scope);
+        };
+    };
+}
+
+exports.makeSumObserver = makeCollectionObserverMaker(function setup() {
+    var sum = 0;
+    return function rangeChange(plus, minus, index) {
+        plus = plus.filter(isNumber);
+        minus = minus.filter(isNumber);
+        sum += plus.sum() - minus.sum();
+        return sum;
+    };
+});
+
+exports.makeAverageObserver = makeCollectionObserverMaker(function setup() {
+    var sum = 0;
+    var count = 0;
+    return function rangeChange(plus, minus, index) {
+        plus = plus.filter(isNumber);
+        minus = minus.filter(isNumber);
+        sum += plus.sum() - minus.sum();
+        count += plus.length - minus.length;
+        return sum / count;
+    };
+});
+
+function isNumber(value) {
+    return typeof value === "number" && !isNaN(value);
+}
+
+// contacts.view{start, length}
+exports.makeViewObserver = makeNonReplacing(makeReplacingViewObserver);
+function makeReplacingViewObserver(observeInput, observeStart, observeLength) {
+    if (!observeLength) {
+        observeLength = observeStart;
+        observeStart = observeZero;
+    }
+    return function observeView(emit, scope) {
+        return observeInput(function (input) {
+            if (!input) return emit();
+
+            var output = [];
+            var length;
+            var start;
+            var boundedLength;
+            var boundedStart;
+            var active = false;
+
+            var cancelRangeChangeObserver = observeRangeChange(input, rangeChange, scope);
+
+            var cancelLengthObserver = observeLength(function replaceLength(newLength) {
+                newLength = +newLength;
+                if (isNaN(newLength)) {
+                    newLength = undefined;
+                }
+                var becomesActive = typeof newLength === "number" && typeof start === "number";
+                var newBoundedLength = Math.max(0, newLength);
+                if (typeof boundedStart === "number") {
+                    newBoundedLength = Math.min(newBoundedLength, input.length - boundedStart);
+                }
+                if (active !== becomesActive) {
+                    if (becomesActive) {
+                        output.swap(0, 0, input.slice(boundedStart, boundedStart + newBoundedLength));
+                    } else {
+                        output.clear();
+                    }
+                    active = becomesActive;
+                } else if (active && boundedLength !== newBoundedLength) {
+                    if (newBoundedLength < boundedLength) { // shrink
+                        // A B C D E F
+                        output.splice(newLength, boundedLength - newBoundedLength);
+                        // A B C D
+                    } else { // grow
+                        // A B C D
+                        output.swap(boundedLength, 0, input.slice(boundedStart + boundedLength, boundedStart + newBoundedLength));
+                        // A B C D E F
+                    }
+                } // otherwise, was inactive, remains inactive
+                length = newLength;
+                boundedLength = newBoundedLength;
+            }, scope);
+
+            var cancelStartObserver = observeStart(function replaceStart(newStart) {
+                newStart = +newStart;
+                if (isNaN(newStart)) {
+                    newStart = undefined;
+                }
+                var becomesActive = typeof length === "number" && typeof newStart === "number";
+                var newBoundedStart = Math.max(0, newStart);
+                if (typeof length === "number") {
+                    newBoundedStart = Math.min(newBoundedStart, input.length);
+                }
+                var newBoundedLength = Math.max(0, length);
+                if (typeof newBoundedStart === "number") {
+                    newBoundedLength = Math.min(newBoundedLength, input.length - newBoundedStart);
+                }
+                if (active !== becomesActive) {
+                    if (becomesActive) {
+                        output.swap(0, output.length, input.slice(newBoundedStart, newBoundedStart + newBoundedLength));
+                    } else {
+                        output.clear();
+                    }
+                    active = becomesActive;
+                } else if (active && boundedStart !== newBoundedStart) {
+                    var diff = Math.abs(newBoundedStart - boundedStart);
+                    if (diff < boundedLength && newBoundedStart < boundedStart) { // rolling backward
+                        // old:     C D E F
+                        output.swap(0, 0, input.slice(newBoundedStart, boundedStart));
+                        // mid: A B C D E F
+                        output.splice(newBoundedLength, output.length - newBoundedLength);
+                        // new: A B C D
+                    } else if (diff < boundedLength && newBoundedStart > boundedStart) { // rolling forward
+                        // old: A B C D
+                        output.swap(output.length, 0, input.slice(boundedStart + boundedLength, newBoundedStart + newBoundedLength));
+                        // mid: A B C D E F
+                        output.splice(0, output.length - newBoundedLength);
+                        // new:     C D E F
+                    } else {
+                        // a new window that does not overlap the previous
+                        output.swap(0, output.length, input.slice(newBoundedStart, newBoundedStart + newBoundedLength));
+                    }
+                } // otherwise, was inactive, remains inactive
+                start = newStart;
+                boundedStart = newBoundedStart;
+                boundedLength = newBoundedLength;
+            }, scope);
+
+            function rangeChange(plus, minus, index) {
+                if (!active) {
+                    return;
+                }
+                var diff = plus.length - minus.length;
+                if (index <= start) { // before window
+                    if (diff > 0) { // grow by diff on leading side, rolling forward
+                        // 0 1 2 3 4 5
+                        //   ----- (start 1, length 3)
+                        // A C D E F
+                        // A>B<C D E F (["B"], [], 1)
+                        // old: C D E
+                        output.swap(0, 0, input.slice(start, start + diff));
+                        // mid: B C D E
+                        output.splice(length, output.length - length);
+                        // new: B C D
+                    } else { // shrink by -diff on leading side, rolling backward
+                        // 0 1 2 3 4 5
+                        //   ----- (start 1, length 3)
+                        // A B C D E F
+                        // A-C D E F ([], ["B"], 1)
+                        // old: B C D
+                        output.splice(0, -diff);
+                        // mid: C D
+                        output.swap(output.length, 0, input.slice(start + output.length, start + length));
+                        // new: C D E
+                    }
+                } else if (index < start + length) { // within the window
+                    output.swap(index - start, minus.length, plus);
+                    if (diff > 0) {
+                        // truncate
+                        output.splice(length, output.length - length);
+                    } else {
+                        // regrow
+                        output.swap(output.length, 0, input.slice(start + output.length, start + length));
+                    }
+                } // after the window
+            }
+
+            var cancel = emit(output) || Function.noop;
+
+            return function cancelViewChangeObserver() {
+                cancel();
+                cancelLengthObserver();
+                cancelStartObserver();
+                cancelRangeChangeObserver();
+            };
+        }, scope);
+    };
+}
+
+var observeZero = makeLiteralObserver(0);
+
+exports.makeEnumerateObserver = makeNonReplacing(makeReplacingEnumerateObserver);
+exports.makeEnumerationObserver = exports.makeEnumerateObserver; // deprecated
+function makeReplacingEnumerateObserver(observeArray) {
+    return function (emit, scope) {
+        return observeArray(function replaceArray(input) {
+            if (!input) return emit();
+
+            var output = [];
+            function update(index) {
+                for (; index < output.length; index++) {
+                    output[index].set(0, index);
+                }
+            }
+            function rangeChange(plus, minus, index) {
+                output.swap(index, minus.length, plus.map(function (value, offset) {
+                    return [index + offset, value];
+                }));
+                update(index + plus.length);
+            }
+            var cancelRangeChange = observeRangeChange(input, rangeChange, scope);
+            var cancel = emit(output) || Function.noop;
+            return function cancelEnumerateObserver() {
+                cancel();
+                cancelRangeChange();
+            };
+        }, scope);
+    };
+}
+
+// length.range() -> [0, 1, 2, ...length]
+exports.makeRangeObserver = makeRangeObserver;
+function makeRangeObserver(observeLength) {
+    return function observeRange(emit, scope) {
+        var output = [];
+        var cancel = emit(output) || Function.noop;
+        var cancelLengthObserver = observeLength(function (length) {
+            length = length >>> 0;
+            if (length == null) {
+                output.clear();
+            } else if (length > output.length) {
+                // pre-fab the extension so the we only have to propagate one
+                // range change to the output.
+                var extension = [];
+                for (var i = output.length; i < length; i++) {
+                    extension.push(i);
+                }
+                output.swap(output.length, 0, extension);
+            } else if (length < output.length) {
+                output.splice(length, output.length);
+            }
+        }, scope) || Function.noop;
+        return function cancelObserveRange() {
+            cancel();
+            cancelLengthObserver();
+        };
+    };
+}
+
+
+// String Observers
+
+exports.makeStartsWithObserver = makeStartsWithObserver;
+function makeStartsWithObserver(observeHaystack, observeNeedle) {
+    return function observeStartsWith(emit, scope) {
+        return observeNeedle(function (needle) {
+            var expression = new RegExp("^" + RegExp.escape(needle));
+            return observeHaystack(function (haystack) {
+                return emit(expression.test(haystack));
+            }, scope);
+        }, scope);
+    };
+}
+
+exports.makeEndsWithObserver = makeEndsWithObserver;
+function makeEndsWithObserver(observeHaystack, observeNeedle) {
+    return function observeEndsWith(emit, scope) {
+        return observeNeedle(function (needle) {
+            var expression = new RegExp(RegExp.escape(needle) + "$");
+            return observeHaystack(function (haystack) {
+                return emit(expression.test(haystack));
+            }, scope);
+        }, scope);
+    };
+}
+
+exports.makeContainsObserver = makeContainsObserver;
+function makeContainsObserver(observeHaystack, observeNeedle) {
+    return function observeContains(emit, scope) {
+        return observeNeedle(function (needle) {
+            var expression = new RegExp(RegExp.escape(needle));
+            return observeHaystack(function (haystack) {
+                return emit(expression.test(haystack));
+            }, scope);
+        }, scope);
+    };
+}
+
+exports.makeJoinObserver = makeJoinObserver;
+function makeJoinObserver(observeArray, observeDelimiter) {
+    observeDelimiter = observeDelimiter || observeNullString;
+    return function observeJoin(emit, scope) {
+        return observeArray(function changeJoinArray(array) {
+            if (!array) return emit();
+            return observeDelimiter(function changeJoinDelimiter(delimiter) {
+                if (typeof delimiter !== "string") return emit();
+                var cancel = Function.noop;
+                function rangeChange() {
+                    cancel = emit(array.join(delimiter)) || Function.noop;
+                }
+                var cancelRangeChange = observeRangeChange(array, rangeChange, scope);
+                return function cancelJoinObserver() {
+                    cancelRangeChange();
+                    cancel();
+                };
+            }, scope);
+        }, scope);
+    };
+}
+
+var observeNullString = makeLiteralObserver("");
+
+// Collection Observers
+
+exports.observeRangeChange = observeRangeChange;
+function observeRangeChange(collection, emit, scope) {
+    if (!collection)
+        return Function.noop;
+    var cancelChild = Function.noop;
+    if (!collection.toArray) {
+        return Function.noop;
+    }
+    if (!collection.addRangeChangeListener) {
+        return Function.noop;
+    }
+    function rangeChange(plus, minus, index) {
+        cancelChild();
+        cancelChild = emit(plus, minus, index) || Function.noop;
+    }
+    rangeChange(collection.toArray(), [], 0);
+    var cancelRangeChange = collection.addRangeChangeListener(
+        rangeChange,
+        null,
+        scope.beforeChange
+    );
+    return function cancelRangeObserver() {
+        cancelChild();
+        cancelRangeChange();
+    };
+}
+
+// array[array.length - 1]
+// array.last()
+exports.makeLastObserver = makeLastObserver;
+function makeLastObserver(observeCollection) {
+    return function observeLast(emit, scope) {
+        return observeCollection(function (collection) {
+            return _observeLast(collection, emit, scope);
+        }, scope);
+    };
+}
+
+// []
+// [1, 2, 3], [], 0 -> [1, 2, 3] grow from start
+// [4], [], 3 -> [1, 2, 3, 4] grow
+// [], [4], 3 -> [1, 2, 3]
+exports.observeLast = observeLast;
+var _observeLast = observeLast;
+function observeLast(collection, emit, scope) {
+    var lastIndex = -1;
+    var cancel = Function.noop;
+    var prev = null;
+    function rangeChange(plus, minus, index) {
+        lastIndex += plus.length - minus.length;
+        // short circuit if the change does not have the reach to change the
+        // last value
+        if (
+            index + minus.length < lastIndex &&
+            index + plus.length < lastIndex
+        ) {
+            return;
+        }
+        var next = lastIndex < 0 ? null : collection.get(lastIndex);
+        cancel();
+        cancel = emit(next) || Function.noop;
+        prev = next;
+    }
+    var cancelRangeChange = observeRangeChange(collection, rangeChange, scope);
+    return function cancelLastObserver() {
+        cancel();
+        cancelRangeChange();
+    };
+}
+
+exports.makeOnlyObserver = makeOnlyObserver;
+function makeOnlyObserver(observeCollection) {
+    return function (emit, scope) {
+        return observeCollection(makeUniq(function replaceCollectionForOnly(collection) {
+            return observeOnly(collection, emit, scope);
+        }), scope);
+    };
+}
+
+// selectedValues <-> selection.map{value}
+// selectedValue <-> selectedValues.only()
+exports.observeOnly = observeOnly;
+function observeOnly(collection, emit, scope) {
+    var length = 0;
+    function rangeChange(plus, minus, index) {
+        length += plus.length - minus.length;
+        if (length !== 1) return emit();
+        return emit(collection.only());
+    }
+    return observeRangeChange(collection, rangeChange, scope);
+}
+
+exports.makeOneObserver = makeOneObserver;
+function makeOneObserver(observeCollection) {
+    return function (emit, scope) {
+        return observeCollection(makeUniq(function replaceCollectionForOne(collection) {
+            return observeOne(collection, emit, scope);
+        }), scope);
+    };
+}
+
+exports.observeOne = observeOne;
+function observeOne(collection, emit, scope) {
+    var length = 0;
+    function rangeChange(plus, minus, index) {
+        length += plus.length - minus.length;
+        if (length === 0) return emit();
+        return emit(collection.one());
+    }
+    return observeRangeChange(collection, rangeChange, scope);
+}
+
+// this.values = [];
+// this.values.addRangeChangeListener(this, "values") // dispatches handleValuesRangeChange
+// this.defineBinding("values.rangeContent()", {"<-": "otherValues"});
+exports.makeRangeContentObserver = makeRangeContentObserver;
+function makeRangeContentObserver(observeCollection) {
+    return function observeContent(emit, scope) {
+        return observeCollection(function (collection) {
+            if (!collection || !collection.addRangeChangeListener) {
+                return emit(collection);
+            } else {
+                return observeRangeChange(collection, function rangeChange() {
+                    return emit(collection);
+                }, scope);
+            }
+        }, scope);
+    };
+}
+
+exports.makeMapContentObserver = makeMapContentObserver;
+function makeMapContentObserver(observeCollection) {
+    return function observeContent(emit, scope) {
+        return observeCollection(function (collection) {
+            if (!collection || !collection.addMapChangeListener) {
+                return emit(collection);
+            } else {
+                return observeMapChange(collection, function rangeChange() {
+                    return emit(collection);
+                }, scope);
+            }
+        }, scope);
+    };
+}
+
+exports.observeMapChange = observeMapChange;
+function observeMapChange(collection, emit, scope) {
+    if (!collection.addMapChangeListener)
+        return;
+    var cancelers = new Map();
+    function mapChange(value, key, collection) {
+        var cancelChild = cancelers.get(key) || Function.noop;
+        cancelers["delete"](key);
+        cancelChild();
+        cancelChild = emit(value, key, collection) || Function.noop;
+        if (value === undefined) {
+            cancelChild();
+        } else {
+            cancelers.set(key, cancelChild);
+        }
+    }
+    collection.forEach(mapChange);
+    var cancelMapChange = collection.addMapChangeListener(mapChange, scope.beforeChange);
+    return function cancelMapObserver() {
+        cancelers.forEach(function (cancel) {
+            cancel();
+        });
+        cancelMapChange();
+    };
+}
+
+var makeEntriesObserver = exports.makeEntriesObserver = makeNonReplacing(makeReplacingEntriesObserver);
+function makeReplacingEntriesObserver(observeCollection) {
+    return function _observeEntries(emit, scope) {
+        return observeCollection(function (collection) {
+            if (!collection) return emit();
+            return observeEntries(collection, emit, scope);
+        }, scope);
+    };
+}
+
+exports.observeEntries = observeEntries;
+function observeEntries(collection, emit, scope) {
+    var items = [];
+    var keyToEntry = Map();
+    var cancel = emit(items) || Function.noop;
+    // TODO observe addition and deletion with separate observers
+    function mapChange(value, key, collection) {
+        var item, index;
+        if (!keyToEntry.has(key)) { // add
+            item = [key, value];
+            keyToEntry.set(key, item);
+            items.push(item);
+        } else if (value == null) { // delete
+            item = keyToEntry.get(key);
+            keyToEntry["delete"](key);
+            index = items.indexOf(item);
+            items.splice(index, 1);
+        } else { // update
+            item = keyToEntry.get(key);
+            item.set(1, value);
+        }
+    }
+    var cancelMapChange = observeMapChange(collection, mapChange, scope) || Function.noop;
+    return function cancelObserveEntries() {
+        cancel();
+        cancelMapChange();
+    };
+}
+
+exports.makeKeysObserver = makeKeysObserver;
+function makeKeysObserver(observeCollection) {
+    var observeEntries = makeEntriesObserver(observeCollection);
+    return makeMapBlockObserver(observeEntries, observeEntryKey);
+}
+
+exports.observeEntryKey = observeEntryKey;
+function observeEntryKey(emit, scope) {
+    if (!scope.value) return emit();
+    return emit(scope.value[0]);
+}
+
+exports.makeValuesObserver = makeValuesObserver;
+function makeValuesObserver(observeCollection) {
+    var observeEntries = makeEntriesObserver(observeCollection);
+    return makeMapBlockObserver(observeEntries, observeEntryValue);
+}
+
+exports.observeEntryValue = observeEntryValue;
+function observeEntryValue(emit, scope) {
+    if (!scope.value) return emit();
+    return emit(scope.value[1]);
+}
+
+exports.makeToMapObserver = makeToMapObserver;
+function makeToMapObserver(observeObject) {
+    return function observeToMap(emit, scope) {
+        var map = new Map();
+        var cancel = emit(map) || Function.noop;
+
+        var cancelObjectObserver = observeObject(function replaceObject(object) {
+            map.clear();
+            if (!object || typeof object !== "object") return;
+
+            // Must come first because Arrays also implement map changes, but
+            // Maps do not implement range changes.
+            if (object.addRangeChangeListener) { // array/collection of items
+                return observeUniqueEntries(function (entries) {
+                    function rangeChange(plus, minus) {
+                        minus.forEach(function (entry) {
+                            map["delete"](entry[0]);
+                        });
+                        plus.forEach(function (entry) {
+                            map.set(entry[0], entry[1]);
+                        });
+                    }
+                    return observeRangeChange(entries, rangeChange, scope);
+                }, scope.nest(object));
+            } else if (object.addMapChangeListener) { // map reflection
+                return observeMapChange(object, function mapChange(value, key) {
+                    if (value === undefined) {
+                        map["delete"](key);
+                    } else {
+                        map.set(key, value);
+                    }
+                }, scope);
+            } else { // object literal
+                var cancelers = Object.keys(object).map(function (key) {
+                    return _observeProperty(object, key, function (value) {
+                        if (value === undefined) {
+                            map["delete"](key);
+                        } else {
+                            map.set(key, value);
+                        }
+                    }, scope);
+                });
+                return function cancelPropertyObservers() {
+                    cancelEach(cancelers);
+                };
+            }
+        }, scope) || Function.noop;
+
+        return function cancelObjectToMapObserver() {
+            cancel();
+            cancelObjectObserver();
+        };
+    };
+}
+
+// A utility for makeToMapObserver
+// object.group{.0}.map{.1.last()}
+var observeUniqueEntries = makeMapBlockObserver(
+    makeGroupBlockObserver(
+        observeValue,
+        observeEntryKey
+    ),
+    makeLastObserver(observeEntryValue)
+);
+
+
+// Combinatoric Observers
+
+exports.makeParentObserver = makeParentObserver;
+function makeParentObserver(observeExpression) {
+    return function observeParentScope(emit, scope) {
+        if (!scope.parent) {
+            return emit();
+        } else {
+            return observeExpression(emit, scope.parent);
+        }
+    };
+}
+
+exports.makeConverterObserver = makeConverterObserver;
+function makeConverterObserver(observeValue, convert, thisp) {
+    return function observeConversion(emit, scope) {
+        emit = makeUniq(emit);
+        return observeValue(function replaceValue(value) {
+            return emit(convert.call(thisp, value));
+        }, scope);
+    };
+}
+
+exports.makeComputerObserver = makeComputerObserver;
+function makeComputerObserver(observeArgs, compute, thisp) {
+    return function (emit, scope) {
+        emit = makeUniq(emit);
+        return observeArgs(function replaceArgs(args) {
+            if (!args || !args.every(Operators.defined)) return;
+            return emit(compute.apply(thisp, args));
+        }, scope);
+    };
+}
+
+exports.makePathObserver = makeExpressionObserver; // deprecated
+exports.makeExpressionObserver = makeExpressionObserver;
+function makeExpressionObserver(observeInput, observeExpression) {
+    var parse = require("./parse");
+    var compileObserver = require("./compile-observer");
+    return function expressionObserver(emit, scope) {
+        emit = makeUniq(emit);
+        return observeExpression(function replaceExpression(expression) {
+            if (expression == null) return emit();
+            var syntax, observeOutput;
+            try {
+                syntax = parse(expression);
+                observeOutput = compileObserver(syntax);
+            } catch (exception) {
+                return emit();
+            }
+            return observeInput(function replaceInput(input) {
+                return observeOutput(emit, scope.nest(input));
+            }, scope);
+        }, scope);
+    };
+}
+
+// Suppose you have input: {object: {a: 10, b: 20}}
+// This FRB expression: object.(a + b)
+// Uses this combinator:
+exports.makeWithObserver = makeWithObserver;
+function makeWithObserver(observeInput, observeExpression) {
+    return function observeWith(emit, scope) {
+        return observeInput(function replaceInput(input) {
+            if (input == null) return emit();
+            return observeExpression(function replaceValue(value) {
+                if (value == null) return emit();
+                return emit(value);
+            }, scope.nest(input));
+        }, scope);
+    };
+}
+
+exports.makeToArrayObserver = makeNonReplacing(Function.identity);
+exports.makeAsArrayObserver = exports.makeToArrayObserver; // XXX deprecated
+
+// Utility Methods
+// ---------------
+
+var merge = require("./merge").merge;
+
+// A utility for generating map and filter observers because they both replace
+// the output array whenever the input array is replaced.  instead, this
+// wrapper receives the replacement array and mirrors it on an output array
+// that only gets emitted once.
+function makeNonReplacing(wrapped) {
+    return function () {
+        var observe = wrapped.apply(this, arguments);
+        return function observeArrayWithoutReplacing(emit, scope) {
+            var output = [];
+            var cancelObserver = observe(function (input) {
+                function rangeChange(plus, minus, index) {
+                    output.swap(index, minus.length, plus);
+                }
+                if (!input) {
+                    output.clear();
+                } else {
+                    // equivalent to: output.swap(0, output.length, input);
+                    merge(output, input);
+                    // TODO fix problem that this would get called twice on replacement
+                    var cancelRangeChange = input.addRangeChangeListener(
+                        rangeChange,
+                        null,
+                        scope.beforeChange
+                    );
+                    return cancelRangeChange;
+                }
+            }, scope);
+            var cancel = emit(output) || Function.noop;
+            return function cancelNonReplacingObserver() {
+                cancelObserver();
+                cancel();
+            };
+        };
+    };
+}
+
+// wraps an emitter such that repeated values are ignored
+exports.makeUniq = makeUniq;
+function makeUniq(emit) {
+    var previous;
+    return function uniqEmit(next) {
+        if (next !== previous) {
+            var result = emit.apply(this, arguments);
+            previous = next;
+            return result;
+        }
+    };
+}
+
+exports.cancelEach = cancelEach;
+function cancelEach(cancelers) {
+    cancelers.forEach(function (cancel) {
+        if (cancel) {
+            cancel();
+        }
+    });
+}
+
+// This emit function decorator originally ensured that the previous canceller
+// returned by emit would be called before dispatching emit again. This was
+// superfluous and its removal did not incur any noticable memory leakage or
+// correctness issues. In fact, the behavior of equality binders mysteriously
+// improved.
+// XXX deprecated Retained because this function is used in Montage.
+exports.autoCancelPrevious = autoCancelPrevious;
+function autoCancelPrevious(emit) {
+    return function () {
+        return emit.apply(null, arguments) || Function.noop;
+    };
+}
+
+
+},{"./compile-observer":33,"./merge":38,"./operators":64,"./parse":65,"./scope":66,"collections/heap":45,"collections/listen/array-changes":47,"collections/listen/property-changes":49,"collections/map":51,"collections/set":53,"collections/shim":58,"collections/sorted-array":59,"collections/sorted-set":60}],64:[function(require,module,exports){
+
+require("collections/shim-object"); // equals, compare
+require("collections/shim-regexp"); // escape
+var Map = require("collections/map");
+var Set = require("collections/set");
+
+// from highest to lowest precedence
+
+exports.toNumber = function (s) {
+    return +s;
+};
+
+exports.toString = function (value) {
+    if (value == null) {
+        return value;
+    } else if (typeof value === "string" || typeof value === "number") {
+        return "" + value;
+    } else {
+        return null;
+    }
+};
+
+exports.toArray = Array.from;
+
+exports.toMap = Map;
+
+exports.toSet = Set;
+
+exports.not = function (b) {
+    return !b;
+};
+
+exports.neg = function (n) {
+    return -n;
+};
+
+exports.pow = function (a, b) {
+    return Math.pow(a, b);
+};
+
+exports.root = function (a, b) {
+    return Math.pow(a, 1 / b);
+};
+
+exports.log = function (a, b) {
+    return Math.log(a) / Math.log(b);
+};
+
+exports.mul = function (a, b) {
+    return a * b;
+};
+
+exports.div = function (a, b) {
+    return a / b;
+};
+
+exports.mod = function (a, b) {
+    return ((a % b) + b) % b;
+};
+
+exports.rem = function (a, b) {
+    return a % b;
+};
+
+exports.add = function (a, b) {
+    return a + b;
+};
+
+exports.sub = function (a, b) {
+    return a - b;
+};
+
+exports.ceil = function (n) {
+    return Math.ceil(n);
+};
+
+exports.floor = function (n) {
+    return Math.floor(n);
+};
+
+exports.round = function (n) {
+    return Math.round(n);
+};
+
+exports.lt = function (a, b) {
+    return Object.compare(a, b) < 0;
+};
+
+exports.gt = function (a, b) {
+    return Object.compare(a, b) > 0;
+};
+
+exports.le = function (a, b) {
+    return Object.compare(a, b) <= 0;
+};
+
+exports.ge = function (a, b) {
+    return Object.compare(a, b) >= 0;
+};
+
+exports.equals = Object.equals;
+
+exports.compare = Object.compare;
+
+exports.and = function (a, b) {
+    return a && b;
+};
+
+exports.or = function (a, b) {
+    return a || b;
+};
+
+exports.defined = function (value) {
+    return value != null;
+};
+
+// "startsWith", "endsWith", and "contains"  are overridden in
+// complile-observer so they can precompile the regular expression and reuse it
+// in each reaction.
+
+exports.startsWith = function (a, b) {
+    var expression = new RegExp("^" + RegExp.escape(b));
+    return expression.test(a);
+};
+
+exports.endsWith = function (a, b) {
+    var expression = new RegExp(RegExp.escape(b) + "$");
+    return expression.test(a);
+};
+
+exports.contains = function (a, b) {
+    var expression = new RegExp(RegExp.escape(b));
+    return expression.test(a);
+};
+
+exports.join = function (a, b) {
+    return a.join(b || "");
+};
+
+exports.split = function (a, b) {
+    return a.split(b || "");
+};
+
+exports.range = function (stop) {
+    var range = [];
+    for (var start = 0; start < stop; start++) {
+        range.push(start);
+    }
+    return range;
+};
+
+exports.last = function (collection) {
+    return collection.get(collection.length - 1);
+};
+
+
+},{"collections/map":51,"collections/set":53,"collections/shim-object":56,"collections/shim-regexp":57}],65:[function(require,module,exports){
+
+require("collections/shim");
+var grammar = require("./grammar");
+
+module.exports = parse;
+function parse(text, options) {
+    if (Array.isArray(text)) {
+        return {
+            type: "tuple",
+            args: text.map(function (text) {
+                return parse(text, options);
+            })
+        };
+    } else {
+        try {
+            return grammar.parse(text, options || Object.empty);
+        } catch (error) {
+            error.message = (
+                error.message.replace(/[\s\.]+$/, "") + " " +
+                " on line " + error.line + " column " + error.column
+            );
+            throw error;
+        }
+    }
+}
+
+
+},{"./grammar":36,"collections/shim":58}],66:[function(require,module,exports){
+
+module.exports = Scope;
+function Scope(value) {
+    this.parent = null;
+    this.value = value;
+}
+
+Scope.prototype.nest = function (value) {
+    var child = Object.create(this);
+    child.value = value;
+    child.parent = this;
+    return child;
+};
+
+
+},{}],67:[function(require,module,exports){
+"use strict";
+
+var parse = require("./parse");
+var precedence = require("./language").precedence;
+var typeToToken = require("./language").operatorTypes;
+var tokenToType = require("./language").operatorTokens;
+
+module.exports = stringify;
+function stringify(syntax, scope) {
+    return stringify.semantics.stringify(syntax, scope);
+}
+
+function makeBlockStringifier(type) {
+    return function (syntax, scope, stringify) {
+        var chain = type + '{' + stringify(syntax.args[1], scope) + '}';
+        if (syntax.args[0].type === "value") {
+            return chain;
+        } else {
+            return stringify(syntax.args[0], scope) + '.' + chain;
+        }
+    };
+}
+
+stringify.semantics = {
+
+    makeBlockStringifier: makeBlockStringifier,
+
+    stringify: function (syntax, scope, parent) {
+        var stringify = this.stringify.bind(this);
+        var stringifiers = this.stringifiers;
+        var string;
+        function stringifyChild(child) {
+            var arg = stringify(child, scope);
+            if (!arg) return "this";
+            return arg;
+        }
+        if (stringifiers[syntax.type]) {
+            // operators
+            string = stringifiers[syntax.type](syntax, scope, stringify);
+        } else if (syntax.inline) {
+            // inline invocations
+            string = (
+                "&" + syntax.type + "(" +
+                syntax.args.map(stringifyChild).join(", ") + ")"
+            );
+        } else {
+            // method invocations
+            var chain;
+            if (syntax.args.length === 1 && syntax.args[0].type === "mapBlock") {
+                // map block function calls
+                chain = syntax.type + "{" + stringify(syntax.args[0].args[1], scope) + "}";
+                syntax = syntax.args[0];
+            } else {
+                // normal function calls
+                chain = (
+                    syntax.type + "(" +
+                    syntax.args.slice(1).map(stringifyChild).join(", ") + ")"
+                );
+            }
+            // left-side if it exists
+            if (syntax.args[0].type === "value") {
+                string = chain;
+            } else {
+                string = stringify(syntax.args[0], scope) + "." + chain;
+            }
+        }
+        // parenthesize if we're going backward in precedence
+        if (
+            !parent ||
+            (parent.type === syntax.type && parent.type !== "if") ||
+            // TODO check on weirdness of "if"
+            precedence.get(parent.type).has(syntax.type)
+        ) {
+            return string;
+        } else {
+            return "(" + string + ")";
+        }
+    },
+
+    stringifiers: {
+
+        value: function (syntax, scope, stringify) {
+            return '';
+        },
+
+        literal: function (syntax, scope, stringify) {
+            if (typeof syntax.value === 'string') {
+                return "'" + syntax.value.replace("'", "\\'") + "'";
+            } else {
+                return "" + syntax.value;
+            }
+        },
+
+        parameters: function (syntax, scope, stringify) {
+            return '$';
+        },
+
+        record: function (syntax, scope, stringify) {
+            return "{" + Object.map(syntax.args, function (value, key) {
+                var string;
+                if (value.type === "value") {
+                    string = "this";
+                } else {
+                    string = stringify(value, scope);
+                }
+                return key + ": " + string;
+            }).join(", ") + "}";
+        },
+
+        tuple: function (syntax, scope, stringify) {
+            return "[" + Object.map(syntax.args, function (value) {
+                if (value.type === "value") {
+                    return "this";
+                } else {
+                    return stringify(value);
+                }
+            }).join(", ") + "]";
+        },
+
+        component: function (syntax, scope) {
+            var label;
+            if (scope && scope.components && syntax.component) {
+                if (scope.components.getObjectLabel) {
+                    label = scope.components.getObjectLabel(syntax.component);
+                } else if (scope.components.getLabelForObject) {
+                    // I am hoping that we will change Montage to use this API
+                    // for consistency with document.getElementById,
+                    // components.getObjectByLabel, & al
+                    label = scope.components.getLabelForObject(syntax.component);
+                }
+            } else {
+                label = syntax.label;
+            }
+            return '@' + label;
+        },
+
+        element: function (syntax) {
+            return '#' + syntax.id;
+        },
+
+        mapBlock: makeBlockStringifier("map"),
+        filterBlock: makeBlockStringifier("filter"),
+        someBlock: makeBlockStringifier("some"),
+        everyBlock: makeBlockStringifier("every"),
+        sortedBlock: makeBlockStringifier("sorted"),
+        sortedSetBlock: makeBlockStringifier("sortedSet"),
+        groupBlock: makeBlockStringifier("group"),
+        groupMapBlock: makeBlockStringifier("groupMap"),
+        minBlock: makeBlockStringifier("min"),
+        maxBlock: makeBlockStringifier("max"),
+
+        property: function (syntax, scope, stringify) {
+            if (syntax.args[0].type === "value") {
+                if (typeof syntax.args[1].value === "string") {
+                    return syntax.args[1].value;
+                } else if (syntax.args[1].type === "literal") {
+                    return "." + syntax.args[1].value;
+                } else {
+                    return "this[" + stringify(syntax.args[1], scope) + "]";
+                }
+            } else if (syntax.args[0].type === "parameters") {
+                return "$" + syntax.args[1].value;
+            } else if (
+                syntax.args[1].type === "literal" &&
+                /^[\w\d_]+$/.test(syntax.args[1].value)
+            ) {
+                return stringify(syntax.args[0], scope, {
+                    type: "scope"
+                }) + '.' + syntax.args[1].value;
+            } else {
+                return stringify(syntax.args[0], {
+                    type: "scope"
+                }, scope) + '[' + stringify(syntax.args[1], scope) + ']';
+            }
+        },
+
+        "with": function (syntax, scope, stringify) {
+            var right = stringify(syntax.args[1], scope, syntax);
+            return stringify(syntax.args[0], scope) + "." + right;
+        },
+
+        not: function (syntax, scope, stringify) {
+            if (syntax.args[0].type === "equals") {
+                return (
+                    stringify(syntax.args[0].args[0], scope, {type: "equals"}) +
+                    " != " +
+                    stringify(syntax.args[0].args[1], scope, {type: "equals"})
+                );
+            } else {
+                return '!' + stringify(syntax.args[0], scope, syntax)
+            }
+        },
+
+        neg: function (syntax, scope, stringify) {
+            return '-' + stringify(syntax.args[0], scope, syntax)
+        },
+
+        toNumber: function (syntax, scope, stringify) {
+            return '+' + stringify(syntax.args[0], scope, syntax)
+        },
+
+        parent: function (syntax, scope, stringify) {
+            return '^' + stringify(syntax.args[0], scope, syntax)
+        },
+
+        if: function (syntax, scope, stringify) {
+            return (
+                stringify(syntax.args[0], scope, syntax) + " ? " +
+                stringify(syntax.args[1], scope) + " : " +
+                stringify(syntax.args[2], scope)
+            );
+        },
+
+        event: function (syntax, scope, stringify) {
+            return syntax.when + " " + syntax.event + " -> " + stringify(syntax.listener, scope);
+        },
+
+        binding: function (arrow, syntax, scope, stringify) {
+
+            var header = stringify(syntax.args[0], scope) + " " + arrow + " " + stringify(syntax.args[1], scope);
+            var trailer = "";
+
+            var descriptor = syntax.descriptor;
+            if (descriptor) {
+                for (var name in descriptor) {
+                    trailer += ", " + name + ": " + stringify(descriptor[name], scope);
+                }
+            }
+
+            return header + trailer;
+        },
+
+        bind: function (syntax, scope, stringify) {
+            return this.binding("<-", syntax, scope, stringify);
+        },
+
+        bind2: function (syntax, scope, stringify) {
+            return this.binding("<->", syntax, scope, stringify);
+        },
+
+        assign: function (syntax, scope, stringify) {
+            return stringify(syntax.args[0], scope) + ": " + stringify(syntax.args[1], scope);
+        },
+
+        block: function (syntax, scope, stringify) {
+            var header = "@" + syntax.label;
+            if (syntax.connection) {
+                if (syntax.connection === "prototype") {
+                    header += " < ";
+                } else if (syntax.connection === "object") {
+                    header += " : ";
+                }
+                header += stringify({type: 'literal', value: syntax.module});
+                if (syntax.exports && syntax.exports.type !== "value") {
+                    header += " " + stringify(syntax.exports, scope);
+                }
+            }
+            return header + " {\n" + syntax.statements.map(function (statement) {
+                return "    " + stringify(statement, scope) + ";\n";
+            }).join("") + "}\n";
+        },
+
+        sheet: function (syntax, scope, stringify) {
+            return "\n" + syntax.blocks.map(function (block) {
+                return stringify(block, scope);
+            }).join("\n") + "\n";
+        }
+
+    }
+
+};
+
+// book a stringifier for all the defined symbolic operators
+typeToToken.forEach(function (token, type) {
+    stringify.semantics.stringifiers[type] = function (syntax, scope, stringify) {
+        return syntax.args.map(function (child) {
+            return stringify(child, scope, syntax);
+        }).join(" " + token + " ").trim();
+    }
+});
+
+
+},{"./language":37,"./parse":65}],68:[function(require,module,exports){
+
+},{}],69:[function(require,module,exports){
+(function (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 = require('base64-js')
+var ieee754 = require('ieee754')
+var isArray = require('isarray')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * 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.
+ *
+ *   - 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()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+  try {
+    var arr = new Uint8Array(1)
+    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+    return arr.foo() === 42 && // typed array instances can be augmented
+        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
+}
+
+function createBuffer (that, length) {
+  if (kMaxLength() < length) {
+    throw new RangeError('Invalid typed array length')
+  }
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = new Uint8Array(length)
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    if (that === null) {
+      that = new Buffer(length)
+    }
+    that.length = length
+  }
+
+  return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+    return new Buffer(arg, encodingOrOffset, length)
+  }
+
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new Error(
+        'If encoding is specified then the first argument must be a string'
+      )
+    }
+    return allocUnsafe(this, arg)
+  }
+  return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+  arr.__proto__ = Buffer.prototype
+  return arr
+}
+
+function from (that, value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
+
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    return fromArrayBuffer(that, value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'string') {
+    return fromString(that, value, encodingOrOffset)
+  }
+
+  return fromObject(that, value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(null, value, encodingOrOffset, length)
+}
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+  Buffer.prototype.__proto__ = Uint8Array.prototype
+  Buffer.__proto__ = Uint8Array
+  if (typeof Symbol !== 'undefined' && Symbol.species &&
+      Buffer[Symbol.species] === Buffer) {
+    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+    Object.defineProperty(Buffer, Symbol.species, {
+      value: null,
+      configurable: true
+    })
+  }
+}
+
+function assertSize (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be a number')
+  } else if (size < 0) {
+    throw new RangeError('"size" argument must not be negative')
+  }
+}
+
+function alloc (that, size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(that, size)
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpretted as a start offset.
+    return typeof encoding === 'string'
+      ? createBuffer(that, size).fill(fill, encoding)
+      : createBuffer(that, size).fill(fill)
+  }
+  return createBuffer(that, size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(null, size, fill, encoding)
+}
+
+function allocUnsafe (that, size) {
+  assertSize(size)
+  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+    for (var i = 0; i < size; ++i) {
+      that[i] = 0
+    }
+  }
+  return that
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(null, size)
+}
+
+function fromString (that, string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
+
+  var length = byteLength(string, encoding) | 0
+  that = createBuffer(that, length)
+
+  var actual = that.write(string, encoding)
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    that = that.slice(0, actual)
+  }
+
+  return that
+}
+
+function fromArrayLike (that, array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  that = createBuffer(that, length)
+  for (var i = 0; i < length; i += 1) {
+    that[i] = array[i] & 255
+  }
+  return that
+}
+
+function fromArrayBuffer (that, array, byteOffset, length) {
+  array.byteLength // this throws if `array` is not a valid ArrayBuffer
+
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('\'offset\' is out of bounds')
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('\'length\' is out of bounds')
+  }
+
+  if (byteOffset === undefined && length === undefined) {
+    array = new Uint8Array(array)
+  } else if (length === undefined) {
+    array = new Uint8Array(array, byteOffset)
+  } else {
+    array = new Uint8Array(array, byteOffset, length)
+  }
+
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = array
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    that = fromArrayLike(that, array)
+  }
+  return that
+}
+
+function fromObject (that, obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    that = createBuffer(that, len)
+
+    if (that.length === 0) {
+      return that
+    }
+
+    obj.copy(that, 0, 0, len)
+    return that
+  }
+
+  if (obj) {
+    if ((typeof ArrayBuffer !== 'undefined' &&
+        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+      if (typeof obj.length !== 'number' || isnan(obj.length)) {
+        return createBuffer(that, 0)
+      }
+      return fromArrayLike(that, obj)
+    }
+
+    if (obj.type === 'Buffer' && isArray(obj.data)) {
+      return fromArrayLike(that, obj.data)
+    }
+  }
+
+  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
+
+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 (length) {
+  if (+length != length) { // eslint-disable-line eqeqeq
+    length = 0
+  }
+  return Buffer.alloc(+length)
+}
+
+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
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i]
+      y = b[i]
+      break
+    }
+  }
+
+  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 'latin1':
+    case 'binary':
+    case 'base64':
+    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 Buffer.alloc(0)
+  }
+
+  var i
+  if (length === undefined) {
+    length = 0
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length
+    }
+  }
+
+  var buffer = Buffer.allocUnsafe(length)
+  var pos = 0
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i]
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers')
+    }
+    buf.copy(buffer, pos)
+    pos += buf.length
+  }
+  return buffer
+}
+
+function byteLength (string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length
+  }
+  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+    return string.byteLength
+  }
+  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 'latin1':
+      case 'binary':
+        return len
+      case 'utf8':
+      case 'utf-8':
+      case undefined:
+        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
+
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
+
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return ''
+  }
+
+  if (end === undefined || end > this.length) {
+    end = this.length
+  }
+
+  if (end <= 0) {
+    return ''
+  }
+
+  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0
+  start >>>= 0
+
+  if (end <= start) {
+    return ''
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  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 'latin1':
+      case 'binary':
+        return latin1Slice(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
+    }
+  }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+  var i = b[n]
+  b[n] = b[m]
+  b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+  var len = this.length
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits')
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1)
+  }
+  return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+  var len = this.length
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits')
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3)
+    swap(this, i + 1, i + 2)
+  }
+  return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+  var len = this.length
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits')
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7)
+    swap(this, i + 1, i + 6)
+    swap(this, i + 2, i + 5)
+    swap(this, i + 3, i + 4)
+  }
+  return this
+}
+
+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 (target, start, end, thisStart, thisEnd) {
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError('Argument must be a Buffer')
+  }
+
+  if (start === undefined) {
+    start = 0
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0
+  }
+  if (thisStart === undefined) {
+    thisStart = 0
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index')
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0
+  }
+  if (thisStart >= thisEnd) {
+    return -1
+  }
+  if (start >= end) {
+    return 1
+  }
+
+  start >>>= 0
+  end >>>= 0
+  thisStart >>>= 0
+  thisEnd >>>= 0
+
+  if (this === target) return 0
+
+  var x = thisEnd - thisStart
+  var y = end - start
+  var len = Math.min(x, y)
+
+  var thisCopy = this.slice(thisStart, thisEnd)
+  var targetCopy = target.slice(start, end)
+
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i]
+      y = targetCopy[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1
+
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset
+    byteOffset = 0
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000
+  }
+  byteOffset = +byteOffset  // Coerce to Number.
+  if (isNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : (buffer.length - 1)
+  }
+
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1
+    else byteOffset = buffer.length - 1
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0
+    else return -1
+  }
+
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding)
+  }
+
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+  } else if (typeof val === 'number') {
+    val = val & 0xFF // Search for a byte value [0-255]
+    if (Buffer.TYPED_ARRAY_SUPPORT &&
+        typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+      }
+    }
+    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+  }
+
+  throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1
+  var arrLength = arr.length
+  var valLength = val.length
+
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase()
+    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+        encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1
+      }
+      indexSize = 2
+      arrLength /= 2
+      valLength /= 2
+      byteOffset /= 2
+    }
+  }
+
+  function read (buf, i) {
+    if (indexSize === 1) {
+      return buf[i]
+    } else {
+      return buf.readUInt16BE(i * indexSize)
+    }
+  }
+
+  var i
+  if (dir) {
+    var foundIndex = -1
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex
+        foundIndex = -1
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false
+          break
+        }
+      }
+      if (found) return i
+    }
+  }
+
+  return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+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 TypeError('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)) return i
+    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 latin1Write (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 {
+    throw new Error(
+      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+    )
+  }
+
+  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 'latin1':
+      case 'binary':
+        return latin1Write(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 latin1Slice (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 = this.subarray(start, end)
+    newBuf.__proto__ = Buffer.prototype
+  } else {
+    var sliceLen = end - start
+    newBuf = new Buffer(sliceLen, undefined)
+    for (var i = 0; i < sliceLen; ++i) {
+      newBuf[i] = this[i + start]
+    }
+  }
+
+  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" argument must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('"value" argument 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) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 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) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 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 = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1
+    }
+    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 = 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1
+    }
+    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 (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 {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, start + len),
+      targetStart
+    )
+  }
+
+  return len
+}
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start
+      start = 0
+      end = this.length
+    } else if (typeof end === 'string') {
+      encoding = end
+      end = this.length
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if (code < 256) {
+        val = code
+      }
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string')
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding)
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  }
+
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index')
+  }
+
+  if (end <= start) {
+    return this
+  }
+
+  start = start >>> 0
+  end = end === undefined ? this.length : end >>> 0
+
+  if (!val) val = 0
+
+  var i
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val)
+      ? val
+      : utf8ToBytes(new Buffer(val, encoding).toString())
+    var len = bytes.length
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len]
+    }
+  }
+
+  return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+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
+}
+
+function isnan (val) {
+  return val !== val // eslint-disable-line no-self-compare
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"base64-js":70,"ieee754":71,"isarray":72}],70:[function(require,module,exports){
+'use strict'
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i]
+  revLookup[code.charCodeAt(i)] = i
+}
+
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function placeHoldersCount (b64) {
+  var len = b64.length
+  if (len % 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
+  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
+}
+
+function byteLength (b64) {
+  // base64 is 4/3 + up to two characters of the original data
+  return b64.length * 3 / 4 - placeHoldersCount(b64)
+}
+
+function toByteArray (b64) {
+  var i, j, l, tmp, placeHolders, arr
+  var len = b64.length
+  placeHolders = placeHoldersCount(b64)
+
+  arr = new Arr(len * 3 / 4 - placeHolders)
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  l = placeHolders > 0 ? len - 4 : len
+
+  var L = 0
+
+  for (i = 0, j = 0; i < l; i += 4, j += 3) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
+    arr[L++] = (tmp >> 16) & 0xFF
+    arr[L++] = (tmp >> 8) & 0xFF
+    arr[L++] = tmp & 0xFF
+  }
+
+  if (placeHolders === 2) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
+    arr[L++] = tmp & 0xFF
+  } else if (placeHolders === 1) {
+    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
+    arr[L++] = (tmp >> 8) & 0xFF
+    arr[L++] = tmp & 0xFF
+  }
+
+  return arr
+}
+
+function tripletToBase64 (num) {
+  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+  var tmp
+  var output = []
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+    output.push(tripletToBase64(tmp))
+  }
+  return output.join('')
+}
+
+function fromByteArray (uint8) {
+  var tmp
+  var len = uint8.length
+  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+  var output = ''
+  var parts = []
+  var maxChunkLength = 16383 // must be multiple of 3
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1]
+    output += lookup[tmp >> 2]
+    output += lookup[(tmp << 4) & 0x3F]
+    output += '=='
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
+    output += lookup[tmp >> 10]
+    output += lookup[(tmp >> 4) & 0x3F]
+    output += lookup[(tmp << 2) & 0x3F]
+    output += '='
+  }
+
+  parts.push(output)
+
+  return parts.join('')
+}
+
+},{}],71:[function(require,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
+}
+
+},{}],72:[function(require,module,exports){
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+  return toString.call(arr) == '[object Array]';
+};
+
+},{}],73:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events)
+    this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
+        // At least give some kind of context to the user
+        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+        err.context = er;
+        throw err;
+      }
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler))
+    return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        args = Array.prototype.slice.call(arguments, 1);
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    args = Array.prototype.slice.call(arguments, 1);
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events)
+    this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type])
+    return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0)
+      return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
+
+  if (!this._events)
+    return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else if (listeners) {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.prototype.listenerCount = function(type) {
+  if (this._events) {
+    var evlistener = this._events[type];
+
+    if (isFunction(evlistener))
+      return 1;
+    else if (evlistener)
+      return evlistener.length;
+  }
+  return 0;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  return emitter.listenerCount(type);
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+},{}],74:[function(require,module,exports){
+var http = require('http');
+
+var https = module.exports;
+
+for (var key in http) {
+    if (http.hasOwnProperty(key)) https[key] = http[key];
+};
+
+https.request = function (params, cb) {
+    if (!params) params = {};
+    params.scheme = 'https';
+    params.protocol = 'https:';
+    return http.request.call(this, params, cb);
+}
+
+},{"http":94}],75:[function(require,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
+  }
+}
+
+},{}],76:[function(require,module,exports){
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+}
+
+function isBuffer (obj) {
+  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
+
+},{}],77:[function(require,module,exports){
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+},{}],78:[function(require,module,exports){
+(function (global){
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+;(function(root) {
+
+	/** Detect free variables */
+	var freeExports = typeof exports == 'object' && exports &&
+		!exports.nodeType && exports;
+	var freeModule = typeof module == 'object' && module &&
+		!module.nodeType && module;
+	var freeGlobal = typeof global == 'object' && global;
+	if (
+		freeGlobal.global === freeGlobal ||
+		freeGlobal.window === freeGlobal ||
+		freeGlobal.self === freeGlobal
+	) {
+		root = freeGlobal;
+	}
+
+	/**
+	 * The `punycode` object.
+	 * @name punycode
+	 * @type Object
+	 */
+	var punycode,
+
+	/** Highest positive signed 32-bit float value */
+	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+	/** Bootstring parameters */
+	base = 36,
+	tMin = 1,
+	tMax = 26,
+	skew = 38,
+	damp = 700,
+	initialBias = 72,
+	initialN = 128, // 0x80
+	delimiter = '-', // '\x2D'
+
+	/** Regular expressions */
+	regexPunycode = /^xn--/,
+	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
+
+	/** Error messages */
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	},
+
+	/** Convenience shortcuts */
+	baseMinusTMin = base - tMin,
+	floor = Math.floor,
+	stringFromCharCode = String.fromCharCode,
+
+	/** Temporary variable */
+	key;
+
+	/*--------------------------------------------------------------------------*/
+
+	/**
+	 * A generic error utility function.
+	 * @private
+	 * @param {String} type The error type.
+	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+	 */
+	function error(type) {
+		throw new RangeError(errors[type]);
+	}
+
+	/**
+	 * A generic `Array#map` utility function.
+	 * @private
+	 * @param {Array} array The array to iterate over.
+	 * @param {Function} callback The function that gets called for every array
+	 * item.
+	 * @returns {Array} A new array of values returned by the callback function.
+	 */
+	function map(array, fn) {
+		var length = array.length;
+		var result = [];
+		while (length--) {
+			result[length] = fn(array[length]);
+		}
+		return result;
+	}
+
+	/**
+	 * A simple `Array#map`-like wrapper to work with domain name strings or email
+	 * addresses.
+	 * @private
+	 * @param {String} domain The domain name or email address.
+	 * @param {Function} callback The function that gets called for every
+	 * character.
+	 * @returns {Array} A new string of characters returned by the callback
+	 * function.
+	 */
+	function mapDomain(string, fn) {
+		var parts = string.split('@');
+		var result = '';
+		if (parts.length > 1) {
+			// In email addresses, only the domain name should be punycoded. Leave
+			// the local part (i.e. everything up to `@`) intact.
+			result = parts[0] + '@';
+			string = parts[1];
+		}
+		// Avoid `split(regex)` for IE8 compatibility. See #17.
+		string = string.replace(regexSeparators, '\x2E');
+		var labels = string.split('.');
+		var encoded = map(labels, fn).join('.');
+		return result + encoded;
+	}
+
+	/**
+	 * Creates an array containing the numeric code points of each Unicode
+	 * character in the string. While JavaScript uses UCS-2 internally,
+	 * this function will convert a pair of surrogate halves (each of which
+	 * UCS-2 exposes as separate characters) into a single code point,
+	 * matching UTF-16.
+	 * @see `punycode.ucs2.encode`
+	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode.ucs2
+	 * @name decode
+	 * @param {String} string The Unicode input string (UCS-2).
+	 * @returns {Array} The new array of code points.
+	 */
+	function ucs2decode(string) {
+		var output = [],
+		    counter = 0,
+		    length = string.length,
+		    value,
+		    extra;
+		while (counter < length) {
+			value = string.charCodeAt(counter++);
+			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+				// high surrogate, and there is a next character
+				extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+				} else {
+					// unmatched surrogate; only append this code unit, in case the next
+					// code unit is the high surrogate of a surrogate pair
+					output.push(value);
+					counter--;
+				}
+			} else {
+				output.push(value);
+			}
+		}
+		return output;
+	}
+
+	/**
+	 * Creates a string based on an array of numeric code points.
+	 * @see `punycode.ucs2.decode`
+	 * @memberOf punycode.ucs2
+	 * @name encode
+	 * @param {Array} codePoints The array of numeric code points.
+	 * @returns {String} The new Unicode string (UCS-2).
+	 */
+	function ucs2encode(array) {
+		return map(array, function(value) {
+			var output = '';
+			if (value > 0xFFFF) {
+				value -= 0x10000;
+				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+				value = 0xDC00 | value & 0x3FF;
+			}
+			output += stringFromCharCode(value);
+			return output;
+		}).join('');
+	}
+
+	/**
+	 * Converts a basic code point into a digit/integer.
+	 * @see `digitToBasic()`
+	 * @private
+	 * @param {Number} codePoint The basic numeric code point value.
+	 * @returns {Number} The numeric value of a basic code point (for use in
+	 * representing integers) in the range `0` to `base - 1`, or `base` if
+	 * the code point does not represent a value.
+	 */
+	function basicToDigit(codePoint) {
+		if (codePoint - 48 < 10) {
+			return codePoint - 22;
+		}
+		if (codePoint - 65 < 26) {
+			return codePoint - 65;
+		}
+		if (codePoint - 97 < 26) {
+			return codePoint - 97;
+		}
+		return base;
+	}
+
+	/**
+	 * Converts a digit/integer into a basic code point.
+	 * @see `basicToDigit()`
+	 * @private
+	 * @param {Number} digit The numeric value of a basic code point.
+	 * @returns {Number} The basic code point whose value (when used for
+	 * representing integers) is `digit`, which needs to be in the range
+	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+	 * used; else, the lowercase form is used. The behavior is undefined
+	 * if `flag` is non-zero and `digit` has no uppercase form.
+	 */
+	function digitToBasic(digit, flag) {
+		//  0..25 map to ASCII a..z or A..Z
+		// 26..35 map to ASCII 0..9
+		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+	}
+
+	/**
+	 * Bias adaptation function as per section 3.4 of RFC 3492.
+	 * https://tools.ietf.org/html/rfc3492#section-3.4
+	 * @private
+	 */
+	function adapt(delta, numPoints, firstTime) {
+		var k = 0;
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
+		delta += floor(delta / numPoints);
+		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+			delta = floor(delta / baseMinusTMin);
+		}
+		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+	}
+
+	/**
+	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+	 * symbols.
+	 * @memberOf punycode
+	 * @param {String} input The Punycode string of ASCII-only symbols.
+	 * @returns {String} The resulting string of Unicode symbols.
+	 */
+	function decode(input) {
+		// Don't use UCS-2
+		var output = [],
+		    inputLength = input.length,
+		    out,
+		    i = 0,
+		    n = initialN,
+		    bias = initialBias,
+		    basic,
+		    j,
+		    index,
+		    oldi,
+		    w,
+		    k,
+		    digit,
+		    t,
+		    /** Cached calculation results */
+		    baseMinusT;
+
+		// Handle the basic code points: let `basic` be the number of input code
+		// points before the last delimiter, or `0` if there is none, then copy
+		// the first basic code points to the output.
+
+		basic = input.lastIndexOf(delimiter);
+		if (basic < 0) {
+			basic = 0;
+		}
+
+		for (j = 0; j < basic; ++j) {
+			// if it's not a basic code point
+			if (input.charCodeAt(j) >= 0x80) {
+				error('not-basic');
+			}
+			output.push(input.charCodeAt(j));
+		}
+
+		// Main decoding loop: start just after the last delimiter if any basic code
+		// points were copied; start at the beginning otherwise.
+
+		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+			// `index` is the index of the next character to be consumed.
+			// Decode a generalized variable-length integer into `delta`,
+			// which gets added to `i`. The overflow checking is easier
+			// if we increase `i` as we go, then subtract off its starting
+			// value at the end to obtain `delta`.
+			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+				if (index >= inputLength) {
+					error('invalid-input');
+				}
+
+				digit = basicToDigit(input.charCodeAt(index++));
+
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
+					error('overflow');
+				}
+
+				i += digit * w;
+				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+				if (digit < t) {
+					break;
+				}
+
+				baseMinusT = base - t;
+				if (w > floor(maxInt / baseMinusT)) {
+					error('overflow');
+				}
+
+				w *= baseMinusT;
+
+			}
+
+			out = output.length + 1;
+			bias = adapt(i - oldi, out, oldi == 0);
+
+			// `i` was supposed to wrap around from `out` to `0`,
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error('overflow');
+			}
+
+			n += floor(i / out);
+			i %= out;
+
+			// Insert `n` at position `i` of the output
+			output.splice(i++, 0, n);
+
+		}
+
+		return ucs2encode(output);
+	}
+
+	/**
+	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
+	 * Punycode string of ASCII-only symbols.
+	 * @memberOf punycode
+	 * @param {String} input The string of Unicode symbols.
+	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+	 */
+	function encode(input) {
+		var n,
+		    delta,
+		    handledCPCount,
+		    basicLength,
+		    bias,
+		    j,
+		    m,
+		    q,
+		    k,
+		    t,
+		    currentValue,
+		    output = [],
+		    /** `inputLength` will hold the number of code points in `input`. */
+		    inputLength,
+		    /** Cached calculation results */
+		    handledCPCountPlusOne,
+		    baseMinusT,
+		    qMinusT;
+
+		// Convert the input in UCS-2 to Unicode
+		input = ucs2decode(input);
+
+		// Cache the length
+		inputLength = input.length;
+
+		// Initialize the state
+		n = initialN;
+		delta = 0;
+		bias = initialBias;
+
+		// Handle the basic code points
+		for (j = 0; j < inputLength; ++j) {
+			currentValue = input[j];
+			if (currentValue < 0x80) {
+				output.push(stringFromCharCode(currentValue));
+			}
+		}
+
+		handledCPCount = basicLength = output.length;
+
+		// `handledCPCount` is the number of code points that have been handled;
+		// `basicLength` is the number of basic code points.
+
+		// Finish the basic string - if it is not empty - with a delimiter
+		if (basicLength) {
+			output.push(delimiter);
+		}
+
+		// Main encoding loop:
+		while (handledCPCount < inputLength) {
+
+			// All non-basic code points < n have been handled already. Find the next
+			// larger one:
+			for (m = maxInt, j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+				if (currentValue >= n && currentValue < m) {
+					m = currentValue;
+				}
+			}
+
+			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+			// but guard against overflow
+			handledCPCountPlusOne = handledCPCount + 1;
+			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+				error('overflow');
+			}
+
+			delta += (m - n) * handledCPCountPlusOne;
+			n = m;
+
+			for (j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+
+				if (currentValue < n && ++delta > maxInt) {
+					error('overflow');
+				}
+
+				if (currentValue == n) {
+					// Represent delta as a generalized variable-length integer
+					for (q = delta, k = base; /* no condition */; k += base) {
+						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+						if (q < t) {
+							break;
+						}
+						qMinusT = q - t;
+						baseMinusT = base - t;
+						output.push(
+							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+						);
+						q = floor(qMinusT / baseMinusT);
+					}
+
+					output.push(stringFromCharCode(digitToBasic(q, 0)));
+					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+					delta = 0;
+					++handledCPCount;
+				}
+			}
+
+			++delta;
+			++n;
+
+		}
+		return output.join('');
+	}
+
+	/**
+	 * Converts a Punycode string representing a domain name or an email address
+	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+	 * it doesn't matter if you call it on a string that has already been
+	 * converted to Unicode.
+	 * @memberOf punycode
+	 * @param {String} input The Punycoded domain name or email address to
+	 * convert to Unicode.
+	 * @returns {String} The Unicode representation of the given Punycode
+	 * string.
+	 */
+	function toUnicode(input) {
+		return mapDomain(input, function(string) {
+			return regexPunycode.test(string)
+				? decode(string.slice(4).toLowerCase())
+				: string;
+		});
+	}
+
+	/**
+	 * Converts a Unicode string representing a domain name or an email address to
+	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
+	 * i.e. it doesn't matter if you call it with a domain that's already in
+	 * ASCII.
+	 * @memberOf punycode
+	 * @param {String} input The domain name or email address to convert, as a
+	 * Unicode string.
+	 * @returns {String} The Punycode representation of the given domain name or
+	 * email address.
+	 */
+	function toASCII(input) {
+		return mapDomain(input, function(string) {
+			return regexNonASCII.test(string)
+				? 'xn--' + encode(string)
+				: string;
+		});
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	punycode = {
+		/**
+		 * A string representing the current Punycode.js version number.
+		 * @memberOf punycode
+		 * @type String
+		 */
+		'version': '1.4.1',
+		/**
+		 * An object of methods to convert from JavaScript's internal character
+		 * representation (UCS-2) to Unicode code points, and back.
+		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+		 * @memberOf punycode
+		 * @type Object
+		 */
+		'ucs2': {
+			'decode': ucs2decode,
+			'encode': ucs2encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/** Expose `punycode` */
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define('punycode', function() {
+			return punycode;
+		});
+	} else if (freeExports && freeModule) {
+		if (module.exports == freeExports) {
+			// in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = punycode;
+		} else {
+			// in Narwhal or RingoJS v0.7.0-
+			for (key in punycode) {
+				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+			}
+		}
+	} else {
+		// in Rhino or a web browser
+		root.punycode = punycode;
+	}
+
+}(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],79:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// If obj.hasOwnProperty has been overridden, then calling
+// obj.hasOwnProperty(prop) will break.
+// See: https://github.com/joyent/node/issues/1707
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+module.exports = function(qs, sep, eq, options) {
+  sep = sep || '&';
+  eq = eq || '=';
+  var obj = {};
+
+  if (typeof qs !== 'string' || qs.length === 0) {
+    return obj;
+  }
+
+  var regexp = /\+/g;
+  qs = qs.split(sep);
+
+  var maxKeys = 1000;
+  if (options && typeof options.maxKeys === 'number') {
+    maxKeys = options.maxKeys;
+  }
+
+  var len = qs.length;
+  // maxKeys <= 0 means that we should not limit keys count
+  if (maxKeys > 0 && len > maxKeys) {
+    len = maxKeys;
+  }
+
+  for (var i = 0; i < len; ++i) {
+    var x = qs[i].replace(regexp, '%20'),
+        idx = x.indexOf(eq),
+        kstr, vstr, k, v;
+
+    if (idx >= 0) {
+      kstr = x.substr(0, idx);
+      vstr = x.substr(idx + 1);
+    } else {
+      kstr = x;
+      vstr = '';
+    }
+
+    k = decodeURIComponent(kstr);
+    v = decodeURIComponent(vstr);
+
+    if (!hasOwnProperty(obj, k)) {
+      obj[k] = v;
+    } else if (isArray(obj[k])) {
+      obj[k].push(v);
+    } else {
+      obj[k] = [obj[k], v];
+    }
+  }
+
+  return obj;
+};
+
+var isArray = Array.isArray || function (xs) {
+  return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+},{}],80:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var stringifyPrimitive = function(v) {
+  switch (typeof v) {
+    case 'string':
+      return v;
+
+    case 'boolean':
+      return v ? 'true' : 'false';
+
+    case 'number':
+      return isFinite(v) ? v : '';
+
+    default:
+      return '';
+  }
+};
+
+module.exports = function(obj, sep, eq, name) {
+  sep = sep || '&';
+  eq = eq || '=';
+  if (obj === null) {
+    obj = undefined;
+  }
+
+  if (typeof obj === 'object') {
+    return map(objectKeys(obj), function(k) {
+      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+      if (isArray(obj[k])) {
+        return map(obj[k], function(v) {
+          return ks + encodeURIComponent(stringifyPrimitive(v));
+        }).join(sep);
+      } else {
+        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+      }
+    }).join(sep);
+
+  }
+
+  if (!name) return '';
+  return encodeURIComponent(stringifyPrimitive(name)) + eq +
+         encodeURIComponent(stringifyPrimitive(obj));
+};
+
+var isArray = Array.isArray || function (xs) {
+  return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+function map (xs, f) {
+  if (xs.map) return xs.map(f);
+  var res = [];
+  for (var i = 0; i < xs.length; i++) {
+    res.push(f(xs[i], i));
+  }
+  return res;
+}
+
+var objectKeys = Object.keys || function (obj) {
+  var res = [];
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
+  }
+  return res;
+};
+
+},{}],81:[function(require,module,exports){
+'use strict';
+
+exports.decode = exports.parse = require('./decode');
+exports.encode = exports.stringify = require('./encode');
+
+},{"./decode":79,"./encode":80}],82:[function(require,module,exports){
+// 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.
+
+'use strict';
+
+/*<replacement>*/
+
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    keys.push(key);
+  }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+var keys = objectKeys(Writable.prototype);
+for (var v = 0; v < keys.length; v++) {
+  var method = keys[v];
+  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.
+  processNextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+function forEach(xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+},{"./_stream_readable":84,"./_stream_writable":86,"core-util-is":89,"inherits":75,"process-nextick-args":91}],83:[function(require,module,exports){
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</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);
+};
+},{"./_stream_transform":85,"core-util-is":89,"inherits":75}],84:[function(require,module,exports){
+(function (process){
+'use strict';
+
+module.exports = Readable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+/*<replacement>*/
+var EE = require('events').EventEmitter;
+
+var EElistenerCount = function (emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var debugUtil = require('util');
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+  debug = debugUtil.debuglog('stream');
+} else {
+  debug = function () {};
+}
+/*</replacement>*/
+
+var BufferList = require('./internal/streams/BufferList');
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function prependListener(emitter, event, fn) {
+  // Sadly this is not cacheable as some libraries bundle their own
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function') {
+    return emitter.prependListener(event, fn);
+  } else {
+    // This is a hack to make sure that our error handler is attached before any
+    // userland ones.  NEVER DO THIS. This is here only because this code needs
+    // to continue to work with older versions of Node.js that do not include
+    // the prependListener() method. The goal is to eventually remove this hack.
+    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+  }
+}
+
+function ReadableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // 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;
+
+  // 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 = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~ ~this.highWaterMark;
+
+  // A linked list is used to store data chunks instead of an array because the
+  // linked list can remove elements from the beginning faster than
+  // array.shift()
+  this.buffer = new BufferList();
+  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;
+  this.resumeScheduled = false;
+
+  // 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 = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+function Readable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  if (!(this instanceof Readable)) return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  if (options && typeof options.read === 'function') this._read = options.read;
+
+  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 (!state.objectMode && typeof chunk === 'string') {
+    encoding = encoding || state.defaultEncoding;
+    if (encoding !== state.encoding) {
+      chunk = bufferShim.from(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);
+};
+
+Readable.prototype.isPaused = function () {
+  return this._readableState.flowing === false;
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+  var er = chunkInvalid(state, chunk);
+  if (er) {
+    stream.emit('error', er);
+  } else if (chunk === null) {
+    state.reading = false;
+    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 {
+      var skipAdd;
+      if (state.decoder && !addToFront && !encoding) {
+        chunk = state.decoder.write(chunk);
+        skipAdd = !state.objectMode && chunk.length === 0;
+      }
+
+      if (!addToFront) state.reading = false;
+
+      // Don't add to the buffer if we've decoded to an empty string chunk and
+      // we're not in object mode
+      if (!skipAdd) {
+        // 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 = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+  return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2 to prevent increasing hwm excessively in
+    // tiny amounts
+    n--;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    n++;
+  }
+  return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+  if (n <= 0 || state.length === 0 && state.ended) return 0;
+  if (state.objectMode) return 1;
+  if (n !== n) {
+    // Only flow one buffer at a time
+    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+  }
+  // If we're asking for more than the current hwm, then raise the hwm.
+  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+  if (n <= state.length) return n;
+  // Don't have enough
+  if (!state.ended) {
+    state.needReadable = true;
+    return 0;
+  }
+  return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+  debug('read', n);
+  n = parseInt(n, 10);
+  var state = this._readableState;
+  var nOrig = n;
+
+  if (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);
+  } else 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 (!state.reading) n = howMuchToRead(nOrig, state);
+  }
+
+  var ret;
+  if (n > 0) ret = fromList(n, state);else ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  } else {
+    state.length -= n;
+  }
+
+  if (state.length === 0) {
+    // If we have nothing in the buffer, then we want to know
+    // as soon as we *do* get something into the buffer.
+    if (!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) endReadable(this);
+  }
+
+  if (ret !== null) this.emit('data', ret);
+
+  return ret;
+};
+
+function chunkInvalid(state, chunk) {
+  var er = null;
+  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+function onEofChunk(stream, state) {
+  if (state.ended) return;
+  if (state.decoder) {
+    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) processNextTick(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;
+    processNextTick(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('_read() is 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) processNextTick(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);
+
+  var cleanedUp = false;
+  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);
+
+    cleanedUp = true;
+
+    // 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();
+  }
+
+  // If the user pushes more data while we're writing to dest then we'll end up
+  // in ondata again. However, we only want to increase awaitDrain once because
+  // dest will only emit one 'drain' event for the multiple writes.
+  // => Introduce a guard on increasing awaitDrain.
+  var increasedAwaitDrain = false;
+  src.on('data', ondata);
+  function ondata(chunk) {
+    debug('ondata');
+    increasedAwaitDrain = false;
+    var ret = dest.write(chunk);
+    if (false === ret && !increasedAwaitDrain) {
+      // If the user unpiped during `dest.write()`, it is possible
+      // to get stuck in a permanently paused state if that write
+      // also returned false.
+      // => Check whether `dest` is still a piping destination.
+      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+        debug('false write response, pause', src._readableState.awaitDrain);
+        src._readableState.awaitDrain++;
+        increasedAwaitDrain = true;
+      }
+      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 (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+  }
+
+  // Make sure our error handler is attached before userland ones.
+  prependListener(dest, 'error', onerror);
+
+  // 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 && EElistenerCount(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 index = indexOf(state.pipes, dest);
+  if (index === -1) return this;
+
+  state.pipes.splice(index, 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 (ev === 'data') {
+    // Start flowing on next tick if stream isn't explicitly paused
+    if (this._readableState.flowing !== false) this.resume();
+  } else if (ev === 'readable') {
+    var state = this._readableState;
+    if (!state.endEmitted && !state.readableListening) {
+      state.readableListening = state.needReadable = true;
+      state.emittedReadable = false;
+      if (!state.reading) {
+        processNextTick(nReadingNextTick, this);
+      } else if (state.length) {
+        emitReadable(this, state);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+  debug('readable nexttick read 0');
+  self.read(0);
+}
+
+// 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;
+    resume(this, state);
+  }
+  return this;
+};
+
+function resume(stream, state) {
+  if (!state.resumeScheduled) {
+    state.resumeScheduled = true;
+    processNextTick(resume_, stream, state);
+  }
+}
+
+function resume_(stream, state) {
+  if (!state.reading) {
+    debug('resume read 0');
+    stream.read(0);
+  }
+
+  state.resumeScheduled = false;
+  state.awaitDrain = 0;
+  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);
+  while (state.flowing && stream.read() !== null) {}
+}
+
+// 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);
+
+    // don't skip over falsy values in objectMode
+    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !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 (this[i] === undefined && typeof stream[i] === 'function') {
+      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.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+  // nothing buffered
+  if (state.length === 0) return null;
+
+  var ret;
+  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+    // read it all, truncate the list
+    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+    state.buffer.clear();
+  } else {
+    // read part of list
+    ret = fromListPartial(n, state.buffer, state.decoder);
+  }
+
+  return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+  var ret;
+  if (n < list.head.data.length) {
+    // slice is the same for buffers and strings
+    ret = list.head.data.slice(0, n);
+    list.head.data = list.head.data.slice(n);
+  } else if (n === list.head.data.length) {
+    // first chunk is a perfect match
+    ret = list.shift();
+  } else {
+    // result spans more than one buffer
+    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+  }
+  return ret;
+}
+
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+  var p = list.head;
+  var c = 1;
+  var ret = p.data;
+  n -= ret.length;
+  while (p = p.next) {
+    var str = p.data;
+    var nb = n > str.length ? str.length : n;
+    if (nb === str.length) ret += str;else ret += str.slice(0, n);
+    n -= nb;
+    if (n === 0) {
+      if (nb === str.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = str.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  return ret;
+}
+
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+  var ret = bufferShim.allocUnsafe(n);
+  var p = list.head;
+  var c = 1;
+  p.data.copy(ret);
+  n -= p.data.length;
+  while (p = p.next) {
+    var buf = p.data;
+    var nb = n > buf.length ? buf.length : n;
+    buf.copy(ret, ret.length - n, 0, nb);
+    n -= nb;
+    if (n === 0) {
+      if (nb === buf.length) {
+        ++c;
+        if (p.next) list.head = p.next;else list.head = list.tail = null;
+      } else {
+        list.head = p;
+        p.data = buf.slice(nb);
+      }
+      break;
+    }
+    ++c;
+  }
+  list.length -= c;
+  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;
+    processNextTick(endReadableNT, state, stream);
+  }
+}
+
+function endReadableNT(state, stream) {
+  // 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;
+}
+}).call(this,require('_process'))
+},{"./_stream_duplex":82,"./internal/streams/BufferList":87,"_process":77,"buffer":69,"buffer-shims":88,"core-util-is":89,"events":73,"inherits":75,"isarray":90,"process-nextick-args":91,"string_decoder/":100,"util":68}],85:[function(require,module,exports){
+// 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.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+function TransformState(stream) {
+  this.afterTransform = function (er, data) {
+    return afterTransform(stream, er, data);
+  };
+
+  this.needTransform = false;
+  this.transforming = false;
+  this.writecb = null;
+  this.writechunk = null;
+  this.writeencoding = 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 (data !== null && data !== undefined) stream.push(data);
+
+  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(this);
+
+  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;
+
+  if (options) {
+    if (typeof options.transform === 'function') this._transform = options.transform;
+
+    if (typeof options.flush === 'function') this._flush = options.flush;
+  }
+
+  // When the writable side finishes, then flush out anything remaining.
+  this.once('prefinish', function () {
+    if (typeof this._flush === 'function') this._flush(function (er, data) {
+      done(stream, er, data);
+    });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('_transform() is 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 (ts.writechunk !== null && 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, data) {
+  if (er) return stream.emit('error', er);
+
+  if (data !== null && data !== undefined) stream.push(data);
+
+  // 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);
+}
+},{"./_stream_duplex":82,"core-util-is":89,"inherits":75}],86:[function(require,module,exports){
+(function (process){
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+module.exports = Writable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
+/*</replacement>*/
+
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var internalUtil = {
+  deprecate: require('util-deprecate')
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+  this.next = null;
+}
+
+function WritableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // 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;
+
+  // 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 = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~ ~this.highWaterMark;
+
+  // drain event flag.
+  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.bufferedRequest = null;
+  this.lastBufferedRequest = null;
+
+  // 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;
+
+  // count buffered requests
+  this.bufferedRequestCount = 0;
+
+  // allocate the first CorkedRequest, there is always
+  // one allocated and free to use, and we maintain at most two
+  this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+  var current = this.bufferedRequest;
+  var out = [];
+  while (current) {
+    out.push(current);
+    current = current.next;
+  }
+  return out;
+};
+
+(function () {
+  try {
+    Object.defineProperty(WritableState.prototype, 'buffer', {
+      get: internalUtil.deprecate(function () {
+        return this.getBuffer();
+      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
+    });
+  } catch (_) {}
+})();
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+var realHasInstance;
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+  realHasInstance = Function.prototype[Symbol.hasInstance];
+  Object.defineProperty(Writable, Symbol.hasInstance, {
+    value: function (object) {
+      if (realHasInstance.call(this, object)) return true;
+
+      return object && object._writableState instanceof WritableState;
+    }
+  });
+} else {
+  realHasInstance = function (object) {
+    return object instanceof this;
+  };
+}
+
+function Writable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, too.
+  // `realHasInstance` is necessary because using plain `instanceof`
+  // would return false, as no `_writableState` property is attached.
+
+  // Trying to use the custom `instanceof` for Writable here will also break the
+  // Node.js LazyTransform implementation, which has a non-trivial getter for
+  // `_writableState` that would lead to infinite recursion.
+  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+    return new Writable(options);
+  }
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  if (options) {
+    if (typeof options.write === 'function') this._write = options.write;
+
+    if (typeof options.writev === 'function') this._writev = options.writev;
+  }
+
+  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, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  processNextTick(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;
+  var er = false;
+  // Always throw error if a null is written
+  // if we are not in object mode then throw
+  // if it is not a buffer, string, or undefined.
+  if (chunk === null) {
+    er = new TypeError('May not write null values to stream');
+  } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  if (er) {
+    stream.emit('error', er);
+    processNextTick(cb, er);
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function') cb = nop;
+
+  if (state.ended) writeAfterEnd(this, 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.bufferedRequest) clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+  this._writableState.defaultEncoding = encoding;
+  return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+    chunk = bufferShim.from(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 (Buffer.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) {
+    var last = state.lastBufferedRequest;
+    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
+    if (last) {
+      last.next = state.lastBufferedRequest;
+    } else {
+      state.bufferedRequest = state.lastBufferedRequest;
+    }
+    state.bufferedRequestCount += 1;
+  } 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) {
+  --state.pendingcb;
+  if (sync) processNextTick(cb, er);else 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(state);
+
+    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      /*<replacement>*/
+      asyncWrite(afterWrite, stream, state, finished, cb);
+      /*</replacement>*/
+    } 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;
+  var entry = state.bufferedRequest;
+
+  if (stream._writev && entry && entry.next) {
+    // Fast case, write everything using _writev()
+    var l = state.bufferedRequestCount;
+    var buffer = new Array(l);
+    var holder = state.corkedRequestsFree;
+    holder.entry = entry;
+
+    var count = 0;
+    while (entry) {
+      buffer[count] = entry;
+      entry = entry.next;
+      count += 1;
+    }
+
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+    // doWrite is almost always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
+    state.pendingcb++;
+    state.lastBufferedRequest = null;
+    if (holder.next) {
+      state.corkedRequestsFree = holder.next;
+      holder.next = null;
+    } else {
+      state.corkedRequestsFree = new CorkedRequest(state);
+    }
+  } else {
+    // Slow case, write chunks one-by-one
+    while (entry) {
+      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);
+      entry = entry.next;
+      // 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) {
+        break;
+      }
+    }
+
+    if (entry === null) state.lastBufferedRequest = null;
+  }
+
+  state.bufferedRequestCount = 0;
+  state.bufferedRequest = entry;
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+  cb(new Error('_write() is not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined) 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(state) {
+  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+
+function prefinish(stream, state) {
+  if (!state.prefinished) {
+    state.prefinished = true;
+    stream.emit('prefinish');
+  }
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(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) processNextTick(cb);else stream.once('finish', cb);
+  }
+  state.ended = true;
+  stream.writable = false;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+  var _this = this;
+
+  this.next = null;
+  this.entry = null;
+
+  this.finish = function (err) {
+    var entry = _this.entry;
+    _this.entry = null;
+    while (entry) {
+      var cb = entry.callback;
+      state.pendingcb--;
+      cb(err);
+      entry = entry.next;
+    }
+    if (state.corkedRequestsFree) {
+      state.corkedRequestsFree.next = _this;
+    } else {
+      state.corkedRequestsFree = _this;
+    }
+  };
+}
+}).call(this,require('_process'))
+},{"./_stream_duplex":82,"_process":77,"buffer":69,"buffer-shims":88,"core-util-is":89,"events":73,"inherits":75,"process-nextick-args":91,"util-deprecate":92}],87:[function(require,module,exports){
+'use strict';
+
+var Buffer = require('buffer').Buffer;
+/*<replacement>*/
+var bufferShim = require('buffer-shims');
+/*</replacement>*/
+
+module.exports = BufferList;
+
+function BufferList() {
+  this.head = null;
+  this.tail = null;
+  this.length = 0;
+}
+
+BufferList.prototype.push = function (v) {
+  var entry = { data: v, next: null };
+  if (this.length > 0) this.tail.next = entry;else this.head = entry;
+  this.tail = entry;
+  ++this.length;
+};
+
+BufferList.prototype.unshift = function (v) {
+  var entry = { data: v, next: this.head };
+  if (this.length === 0) this.tail = entry;
+  this.head = entry;
+  ++this.length;
+};
+
+BufferList.prototype.shift = function () {
+  if (this.length === 0) return;
+  var ret = this.head.data;
+  if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+  --this.length;
+  return ret;
+};
+
+BufferList.prototype.clear = function () {
+  this.head = this.tail = null;
+  this.length = 0;
+};
+
+BufferList.prototype.join = function (s) {
+  if (this.length === 0) return '';
+  var p = this.head;
+  var ret = '' + p.data;
+  while (p = p.next) {
+    ret += s + p.data;
+  }return ret;
+};
+
+BufferList.prototype.concat = function (n) {
+  if (this.length === 0) return bufferShim.alloc(0);
+  if (this.length === 1) return this.head.data;
+  var ret = bufferShim.allocUnsafe(n >>> 0);
+  var p = this.head;
+  var i = 0;
+  while (p) {
+    p.data.copy(ret, i);
+    i += p.data.length;
+    p = p.next;
+  }
+  return ret;
+};
+},{"buffer":69,"buffer-shims":88}],88:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var buffer = require('buffer');
+var Buffer = buffer.Buffer;
+var SlowBuffer = buffer.SlowBuffer;
+var MAX_LEN = buffer.kMaxLength || 2147483647;
+exports.alloc = function alloc(size, fill, encoding) {
+  if (typeof Buffer.alloc === 'function') {
+    return Buffer.alloc(size, fill, encoding);
+  }
+  if (typeof encoding === 'number') {
+    throw new TypeError('encoding must not be number');
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size > MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  var enc = encoding;
+  var _fill = fill;
+  if (_fill === undefined) {
+    enc = undefined;
+    _fill = 0;
+  }
+  var buf = new Buffer(size);
+  if (typeof _fill === 'string') {
+    var fillBuf = new Buffer(_fill, enc);
+    var flen = fillBuf.length;
+    var i = -1;
+    while (++i < size) {
+      buf[i] = fillBuf[i % flen];
+    }
+  } else {
+    buf.fill(_fill);
+  }
+  return buf;
+}
+exports.allocUnsafe = function allocUnsafe(size) {
+  if (typeof Buffer.allocUnsafe === 'function') {
+    return Buffer.allocUnsafe(size);
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size > MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  return new Buffer(size);
+}
+exports.from = function from(value, encodingOrOffset, length) {
+  if (typeof Buffer.from === 'function' && (!global.Uint8Array || Uint8Array.from !== Buffer.from)) {
+    return Buffer.from(value, encodingOrOffset, length);
+  }
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number');
+  }
+  if (typeof value === 'string') {
+    return new Buffer(value, encodingOrOffset);
+  }
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    var offset = encodingOrOffset;
+    if (arguments.length === 1) {
+      return new Buffer(value);
+    }
+    if (typeof offset === 'undefined') {
+      offset = 0;
+    }
+    var len = length;
+    if (typeof len === 'undefined') {
+      len = value.byteLength - offset;
+    }
+    if (offset >= value.byteLength) {
+      throw new RangeError('\'offset\' is out of bounds');
+    }
+    if (len > value.byteLength - offset) {
+      throw new RangeError('\'length\' is out of bounds');
+    }
+    return new Buffer(value.slice(offset, offset + len));
+  }
+  if (Buffer.isBuffer(value)) {
+    var out = new Buffer(value.length);
+    value.copy(out, 0, 0, value.length);
+    return out;
+  }
+  if (value) {
+    if (Array.isArray(value) || (typeof ArrayBuffer !== 'undefined' && value.buffer instanceof ArrayBuffer) || 'length' in value) {
+      return new Buffer(value);
+    }
+    if (value.type === 'Buffer' && Array.isArray(value.data)) {
+      return new Buffer(value.data);
+    }
+  }
+
+  throw new TypeError('First argument must be a string, Buffer, ' + 'ArrayBuffer, Array, or array-like object.');
+}
+exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  if (typeof Buffer.allocUnsafeSlow === 'function') {
+    return Buffer.allocUnsafeSlow(size);
+  }
+  if (typeof size !== 'number') {
+    throw new TypeError('size must be a number');
+  }
+  if (size >= MAX_LEN) {
+    throw new RangeError('size is too large');
+  }
+  return new SlowBuffer(size);
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"buffer":69}],89:[function(require,module,exports){
+(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);
+}
+
+}).call(this,{"isBuffer":require("../../../../insert-module-globals/node_modules/is-buffer/index.js")})
+},{"../../../../insert-module-globals/node_modules/is-buffer/index.js":76}],90:[function(require,module,exports){
+arguments[4][72][0].apply(exports,arguments)
+},{"dup":72}],91:[function(require,module,exports){
+(function (process){
+'use strict';
+
+if (!process.version ||
+    process.version.indexOf('v0.') === 0 ||
+    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+  module.exports = nextTick;
+} else {
+  module.exports = process.nextTick;
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('"callback" argument must be a function');
+  }
+  var len = arguments.length;
+  var args, i;
+  switch (len) {
+  case 0:
+  case 1:
+    return process.nextTick(fn);
+  case 2:
+    return process.nextTick(function afterTickOne() {
+      fn.call(null, arg1);
+    });
+  case 3:
+    return process.nextTick(function afterTickTwo() {
+      fn.call(null, arg1, arg2);
+    });
+  case 4:
+    return process.nextTick(function afterTickThree() {
+      fn.call(null, arg1, arg2, arg3);
+    });
+  default:
+    args = new Array(len - 1);
+    i = 0;
+    while (i < args.length) {
+      args[i++] = arguments[i];
+    }
+    return process.nextTick(function afterTick() {
+      fn.apply(null, args);
+    });
+  }
+}
+
+}).call(this,require('_process'))
+},{"_process":77}],92:[function(require,module,exports){
+(function (global){
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!global.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = global.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],93:[function(require,module,exports){
+(function (process){
+var Stream = (function (){
+  try {
+    return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify
+  } catch(_){}
+}());
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = Stream || exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+if (!process.browser && process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream;
+}
+
+}).call(this,require('_process'))
+},{"./lib/_stream_duplex.js":82,"./lib/_stream_passthrough.js":83,"./lib/_stream_readable.js":84,"./lib/_stream_transform.js":85,"./lib/_stream_writable.js":86,"_process":77}],94:[function(require,module,exports){
+(function (global){
+var ClientRequest = require('./lib/request')
+var extend = require('xtend')
+var statusCodes = require('builtin-status-codes')
+var url = require('url')
+
+var http = exports
+
+http.request = function (opts, cb) {
+	if (typeof opts === 'string')
+		opts = url.parse(opts)
+	else
+		opts = extend(opts)
+
+	// Normally, the page is loaded from http or https, so not specifying a protocol
+	// will result in a (valid) protocol-relative url. However, this won't work if
+	// the protocol is something else, like 'file:'
+	var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''
+
+	var protocol = opts.protocol || defaultProtocol
+	var host = opts.hostname || opts.host
+	var port = opts.port
+	var path = opts.path || '/'
+
+	// Necessary for IPv6 addresses
+	if (host && host.indexOf(':') !== -1)
+		host = '[' + host + ']'
+
+	// This may be a relative url. The browser should always be able to interpret it correctly.
+	opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path
+	opts.method = (opts.method || 'GET').toUpperCase()
+	opts.headers = opts.headers || {}
+
+	// Also valid opts.auth, opts.mode
+
+	var req = new ClientRequest(opts)
+	if (cb)
+		req.on('response', cb)
+	return req
+}
+
+http.get = function get (opts, cb) {
+	var req = http.request(opts, cb)
+	req.end()
+	return req
+}
+
+http.Agent = function () {}
+http.Agent.defaultMaxSockets = 4
+
+http.STATUS_CODES = statusCodes
+
+http.METHODS = [
+	'CHECKOUT',
+	'CONNECT',
+	'COPY',
+	'DELETE',
+	'GET',
+	'HEAD',
+	'LOCK',
+	'M-SEARCH',
+	'MERGE',
+	'MKACTIVITY',
+	'MKCOL',
+	'MOVE',
+	'NOTIFY',
+	'OPTIONS',
+	'PATCH',
+	'POST',
+	'PROPFIND',
+	'PROPPATCH',
+	'PURGE',
+	'PUT',
+	'REPORT',
+	'SEARCH',
+	'SUBSCRIBE',
+	'TRACE',
+	'UNLOCK',
+	'UNSUBSCRIBE'
+]
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./lib/request":96,"builtin-status-codes":98,"url":101,"xtend":103}],95:[function(require,module,exports){
+(function (global){
+exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)
+
+exports.blobConstructor = false
+try {
+	new Blob([new ArrayBuffer(1)])
+	exports.blobConstructor = true
+} catch (e) {}
+
+// The xhr request to example.com may violate some restrictive CSP configurations,
+// so if we're running in a browser that supports `fetch`, avoid calling getXHR()
+// and assume support for certain features below.
+var xhr
+function getXHR () {
+	// Cache the xhr value
+	if (xhr !== undefined) return xhr
+
+	if (global.XMLHttpRequest) {
+		xhr = new global.XMLHttpRequest()
+		// If XDomainRequest is available (ie only, where xhr might not work
+		// cross domain), use the page location. Otherwise use example.com
+		// Note: this doesn't actually make an http request.
+		try {
+			xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
+		} catch(e) {
+			xhr = null
+		}
+	} else {
+		// Service workers don't have XHR
+		xhr = null
+	}
+	return xhr
+}
+
+function checkTypeSupport (type) {
+	var xhr = getXHR()
+	if (!xhr) return false
+	try {
+		xhr.responseType = type
+		return xhr.responseType === type
+	} catch (e) {}
+	return false
+}
+
+// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.
+// Safari 7.1 appears to have fixed this bug.
+var haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'
+var haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)
+
+// If fetch is supported, then arraybuffer will be supported too. Skip calling
+// checkTypeSupport(), since that calls getXHR().
+exports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))
+
+// These next two tests unavoidably show warnings in Chrome. Since fetch will always
+// be used if it's available, just return false for these to avoid the warnings.
+exports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')
+exports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&
+	checkTypeSupport('moz-chunked-arraybuffer')
+
+// If fetch is supported, then overrideMimeType will be supported too. Skip calling
+// getXHR().
+exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)
+
+exports.vbArray = isFunction(global.VBArray)
+
+function isFunction (value) {
+	return typeof value === 'function'
+}
+
+xhr = null // Help gc
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],96:[function(require,module,exports){
+(function (process,global,Buffer){
+var capability = require('./capability')
+var inherits = require('inherits')
+var response = require('./response')
+var stream = require('readable-stream')
+var toArrayBuffer = require('to-arraybuffer')
+
+var IncomingMessage = response.IncomingMessage
+var rStates = response.readyStates
+
+function decideMode (preferBinary, useFetch) {
+	if (capability.fetch && useFetch) {
+		return 'fetch'
+	} else if (capability.mozchunkedarraybuffer) {
+		return 'moz-chunked-arraybuffer'
+	} else if (capability.msstream) {
+		return 'ms-stream'
+	} else if (capability.arraybuffer && preferBinary) {
+		return 'arraybuffer'
+	} else if (capability.vbArray && preferBinary) {
+		return 'text:vbarray'
+	} else {
+		return 'text'
+	}
+}
+
+var ClientRequest = module.exports = function (opts) {
+	var self = this
+	stream.Writable.call(self)
+
+	self._opts = opts
+	self._body = []
+	self._headers = {}
+	if (opts.auth)
+		self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))
+	Object.keys(opts.headers).forEach(function (name) {
+		self.setHeader(name, opts.headers[name])
+	})
+
+	var preferBinary
+	var useFetch = true
+	if (opts.mode === 'disable-fetch' || 'timeout' in opts) {
+		// If the use of XHR should be preferred and includes preserving the 'content-type' header.
+		// Force XHR to be used since the Fetch API does not yet support timeouts.
+		useFetch = false
+		preferBinary = true
+	} else if (opts.mode === 'prefer-streaming') {
+		// If streaming is a high priority but binary compatibility and
+		// the accuracy of the 'content-type' header aren't
+		preferBinary = false
+	} else if (opts.mode === 'allow-wrong-content-type') {
+		// If streaming is more important than preserving the 'content-type' header
+		preferBinary = !capability.overrideMimeType
+	} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
+		// Use binary if text streaming may corrupt data or the content-type header, or for speed
+		preferBinary = true
+	} else {
+		throw new Error('Invalid value for opts.mode')
+	}
+	self._mode = decideMode(preferBinary, useFetch)
+
+	self.on('finish', function () {
+		self._onFinish()
+	})
+}
+
+inherits(ClientRequest, stream.Writable)
+
+ClientRequest.prototype.setHeader = function (name, value) {
+	var self = this
+	var lowerName = name.toLowerCase()
+	// This check is not necessary, but it prevents warnings from browsers about setting unsafe
+	// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
+	// http-browserify did it, so I will too.
+	if (unsafeHeaders.indexOf(lowerName) !== -1)
+		return
+
+	self._headers[lowerName] = {
+		name: name,
+		value: value
+	}
+}
+
+ClientRequest.prototype.getHeader = function (name) {
+	var self = this
+	return self._headers[name.toLowerCase()].value
+}
+
+ClientRequest.prototype.removeHeader = function (name) {
+	var self = this
+	delete self._headers[name.toLowerCase()]
+}
+
+ClientRequest.prototype._onFinish = function () {
+	var self = this
+
+	if (self._destroyed)
+		return
+	var opts = self._opts
+
+	var headersObj = self._headers
+	var body = null
+	if (opts.method === 'POST' || opts.method === 'PUT' || opts.method === 'PATCH' || opts.method === 'MERGE') {
+		if (capability.blobConstructor) {
+			body = new global.Blob(self._body.map(function (buffer) {
+				return toArrayBuffer(buffer)
+			}), {
+				type: (headersObj['content-type'] || {}).value || ''
+			})
+		} else {
+			// get utf8 string
+			body = Buffer.concat(self._body).toString()
+		}
+	}
+
+	if (self._mode === 'fetch') {
+		var headers = Object.keys(headersObj).map(function (name) {
+			return [headersObj[name].name, headersObj[name].value]
+		})
+
+		global.fetch(self._opts.url, {
+			method: self._opts.method,
+			headers: headers,
+			body: body || undefined,
+			mode: 'cors',
+			credentials: opts.withCredentials ? 'include' : 'same-origin'
+		}).then(function (response) {
+			self._fetchResponse = response
+			self._connect()
+		}, function (reason) {
+			self.emit('error', reason)
+		})
+	} else {
+		var xhr = self._xhr = new global.XMLHttpRequest()
+		try {
+			xhr.open(self._opts.method, self._opts.url, true)
+		} catch (err) {
+			process.nextTick(function () {
+				self.emit('error', err)
+			})
+			return
+		}
+
+		// Can't set responseType on really old browsers
+		if ('responseType' in xhr)
+			xhr.responseType = self._mode.split(':')[0]
+
+		if ('withCredentials' in xhr)
+			xhr.withCredentials = !!opts.withCredentials
+
+		if (self._mode === 'text' && 'overrideMimeType' in xhr)
+			xhr.overrideMimeType('text/plain; charset=x-user-defined')
+
+		if ('timeout' in opts) {
+			xhr.timeout = opts.timeout
+			xhr.ontimeout = function () {
+				self.emit('timeout')
+			}
+		}
+
+		Object.keys(headersObj).forEach(function (name) {
+			xhr.setRequestHeader(headersObj[name].name, headersObj[name].value)
+		})
+
+		self._response = null
+		xhr.onreadystatechange = function () {
+			switch (xhr.readyState) {
+				case rStates.LOADING:
+				case rStates.DONE:
+					self._onXHRProgress()
+					break
+			}
+		}
+		// Necessary for streaming in Firefox, since xhr.response is ONLY defined
+		// in onprogress, not in onreadystatechange with xhr.readyState = 3
+		if (self._mode === 'moz-chunked-arraybuffer') {
+			xhr.onprogress = function () {
+				self._onXHRProgress()
+			}
+		}
+
+		xhr.onerror = function () {
+			if (self._destroyed)
+				return
+			self.emit('error', new Error('XHR error'))
+		}
+
+		try {
+			xhr.send(body)
+		} catch (err) {
+			process.nextTick(function () {
+				self.emit('error', err)
+			})
+			return
+		}
+	}
+}
+
+/**
+ * Checks if xhr.status is readable and non-zero, indicating no error.
+ * Even though the spec says it should be available in readyState 3,
+ * accessing it throws an exception in IE8
+ */
+function statusValid (xhr) {
+	try {
+		var status = xhr.status
+		return (status !== null && status !== 0)
+	} catch (e) {
+		return false
+	}
+}
+
+ClientRequest.prototype._onXHRProgress = function () {
+	var self = this
+
+	if (!statusValid(self._xhr) || self._destroyed)
+		return
+
+	if (!self._response)
+		self._connect()
+
+	self._response._onXHRProgress()
+}
+
+ClientRequest.prototype._connect = function () {
+	var self = this
+
+	if (self._destroyed)
+		return
+
+	self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode)
+	self._response.on('error', function(err) {
+		self.emit('error', err)
+	})
+
+	self.emit('response', self._response)
+}
+
+ClientRequest.prototype._write = function (chunk, encoding, cb) {
+	var self = this
+
+	self._body.push(chunk)
+	cb()
+}
+
+ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
+	var self = this
+	self._destroyed = true
+	if (self._response)
+		self._response._destroyed = true
+	if (self._xhr)
+		self._xhr.abort()
+	// Currently, there isn't a way to truly abort a fetch.
+	// If you like bikeshedding, see https://github.com/whatwg/fetch/issues/27
+}
+
+ClientRequest.prototype.end = function (data, encoding, cb) {
+	var self = this
+	if (typeof data === 'function') {
+		cb = data
+		data = undefined
+	}
+
+	stream.Writable.prototype.end.call(self, data, encoding, cb)
+}
+
+ClientRequest.prototype.flushHeaders = function () {}
+ClientRequest.prototype.setTimeout = function () {}
+ClientRequest.prototype.setNoDelay = function () {}
+ClientRequest.prototype.setSocketKeepAlive = function () {}
+
+// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
+var unsafeHeaders = [
+	'accept-charset',
+	'accept-encoding',
+	'access-control-request-headers',
+	'access-control-request-method',
+	'connection',
+	'content-length',
+	'cookie',
+	'cookie2',
+	'date',
+	'dnt',
+	'expect',
+	'host',
+	'keep-alive',
+	'origin',
+	'referer',
+	'te',
+	'trailer',
+	'transfer-encoding',
+	'upgrade',
+	'user-agent',
+	'via'
+]
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./capability":95,"./response":97,"_process":77,"buffer":69,"inherits":75,"readable-stream":93,"to-arraybuffer":99}],97:[function(require,module,exports){
+(function (process,global,Buffer){
+var capability = require('./capability')
+var inherits = require('inherits')
+var stream = require('readable-stream')
+
+var rStates = exports.readyStates = {
+	UNSENT: 0,
+	OPENED: 1,
+	HEADERS_RECEIVED: 2,
+	LOADING: 3,
+	DONE: 4
+}
+
+var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode) {
+	var self = this
+	stream.Readable.call(self)
+
+	self._mode = mode
+	self.headers = {}
+	self.rawHeaders = []
+	self.trailers = {}
+	self.rawTrailers = []
+
+	// Fake the 'close' event, but only once 'end' fires
+	self.on('end', function () {
+		// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
+		process.nextTick(function () {
+			self.emit('close')
+		})
+	})
+
+	if (mode === 'fetch') {
+		self._fetchResponse = response
+
+		self.url = response.url
+		self.statusCode = response.status
+		self.statusMessage = response.statusText
+		
+		response.headers.forEach(function(header, key){
+			self.headers[key.toLowerCase()] = header
+			self.rawHeaders.push(key, header)
+		})
+
+
+		// TODO: this doesn't respect backpressure. Once WritableStream is available, this can be fixed
+		var reader = response.body.getReader()
+		function read () {
+			reader.read().then(function (result) {
+				if (self._destroyed)
+					return
+				if (result.done) {
+					self.push(null)
+					return
+				}
+				self.push(new Buffer(result.value))
+				read()
+			}).catch(function(err) {
+				self.emit('error', err)
+			})
+		}
+		read()
+
+	} else {
+		self._xhr = xhr
+		self._pos = 0
+
+		self.url = xhr.responseURL
+		self.statusCode = xhr.status
+		self.statusMessage = xhr.statusText
+		var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
+		headers.forEach(function (header) {
+			var matches = header.match(/^([^:]+):\s*(.*)/)
+			if (matches) {
+				var key = matches[1].toLowerCase()
+				if (key === 'set-cookie') {
+					if (self.headers[key] === undefined) {
+						self.headers[key] = []
+					}
+					self.headers[key].push(matches[2])
+				} else if (self.headers[key] !== undefined) {
+					self.headers[key] += ', ' + matches[2]
+				} else {
+					self.headers[key] = matches[2]
+				}
+				self.rawHeaders.push(matches[1], matches[2])
+			}
+		})
+
+		self._charset = 'x-user-defined'
+		if (!capability.overrideMimeType) {
+			var mimeType = self.rawHeaders['mime-type']
+			if (mimeType) {
+				var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
+				if (charsetMatch) {
+					self._charset = charsetMatch[1].toLowerCase()
+				}
+			}
+			if (!self._charset)
+				self._charset = 'utf-8' // best guess
+		}
+	}
+}
+
+inherits(IncomingMessage, stream.Readable)
+
+IncomingMessage.prototype._read = function () {}
+
+IncomingMessage.prototype._onXHRProgress = function () {
+	var self = this
+
+	var xhr = self._xhr
+
+	var response = null
+	switch (self._mode) {
+		case 'text:vbarray': // For IE9
+			if (xhr.readyState !== rStates.DONE)
+				break
+			try {
+				// This fails in IE8
+				response = new global.VBArray(xhr.responseBody).toArray()
+			} catch (e) {}
+			if (response !== null) {
+				self.push(new Buffer(response))
+				break
+			}
+			// Falls through in IE8	
+		case 'text':
+			try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
+				response = xhr.responseText
+			} catch (e) {
+				self._mode = 'text:vbarray'
+				break
+			}
+			if (response.length > self._pos) {
+				var newData = response.substr(self._pos)
+				if (self._charset === 'x-user-defined') {
+					var buffer = new Buffer(newData.length)
+					for (var i = 0; i < newData.length; i++)
+						buffer[i] = newData.charCodeAt(i) & 0xff
+
+					self.push(buffer)
+				} else {
+					self.push(newData, self._charset)
+				}
+				self._pos = response.length
+			}
+			break
+		case 'arraybuffer':
+			if (xhr.readyState !== rStates.DONE || !xhr.response)
+				break
+			response = xhr.response
+			self.push(new Buffer(new Uint8Array(response)))
+			break
+		case 'moz-chunked-arraybuffer': // take whole
+			response = xhr.response
+			if (xhr.readyState !== rStates.LOADING || !response)
+				break
+			self.push(new Buffer(new Uint8Array(response)))
+			break
+		case 'ms-stream':
+			response = xhr.response
+			if (xhr.readyState !== rStates.LOADING)
+				break
+			var reader = new global.MSStreamReader()
+			reader.onprogress = function () {
+				if (reader.result.byteLength > self._pos) {
+					self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))
+					self._pos = reader.result.byteLength
+				}
+			}
+			reader.onload = function () {
+				self.push(null)
+			}
+			// reader.onerror = ??? // TODO: this
+			reader.readAsArrayBuffer(response)
+			break
+	}
+
+	// The ms-stream case handles end separately in reader.onload()
+	if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
+		self.push(null)
+	}
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./capability":95,"_process":77,"buffer":69,"inherits":75,"readable-stream":93}],98:[function(require,module,exports){
+module.exports = {
+  "100": "Continue",
+  "101": "Switching Protocols",
+  "102": "Processing",
+  "200": "OK",
+  "201": "Created",
+  "202": "Accepted",
+  "203": "Non-Authoritative Information",
+  "204": "No Content",
+  "205": "Reset Content",
+  "206": "Partial Content",
+  "207": "Multi-Status",
+  "208": "Already Reported",
+  "226": "IM Used",
+  "300": "Multiple Choices",
+  "301": "Moved Permanently",
+  "302": "Found",
+  "303": "See Other",
+  "304": "Not Modified",
+  "305": "Use Proxy",
+  "307": "Temporary Redirect",
+  "308": "Permanent Redirect",
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "402": "Payment Required",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed",
+  "406": "Not Acceptable",
+  "407": "Proxy Authentication Required",
+  "408": "Request Timeout",
+  "409": "Conflict",
+  "410": "Gone",
+  "411": "Length Required",
+  "412": "Precondition Failed",
+  "413": "Payload Too Large",
+  "414": "URI Too Long",
+  "415": "Unsupported Media Type",
+  "416": "Range Not Satisfiable",
+  "417": "Expectation Failed",
+  "418": "I'm a teapot",
+  "421": "Misdirected Request",
+  "422": "Unprocessable Entity",
+  "423": "Locked",
+  "424": "Failed Dependency",
+  "425": "Unordered Collection",
+  "426": "Upgrade Required",
+  "428": "Precondition Required",
+  "429": "Too Many Requests",
+  "431": "Request Header Fields Too Large",
+  "451": "Unavailable For Legal Reasons",
+  "500": "Internal Server Error",
+  "501": "Not Implemented",
+  "502": "Bad Gateway",
+  "503": "Service Unavailable",
+  "504": "Gateway Timeout",
+  "505": "HTTP Version Not Supported",
+  "506": "Variant Also Negotiates",
+  "507": "Insufficient Storage",
+  "508": "Loop Detected",
+  "509": "Bandwidth Limit Exceeded",
+  "510": "Not Extended",
+  "511": "Network Authentication Required"
+}
+
+},{}],99:[function(require,module,exports){
+var Buffer = require('buffer').Buffer
+
+module.exports = function (buf) {
+	// If the buffer is backed by a Uint8Array, a faster version will work
+	if (buf instanceof Uint8Array) {
+		// If the buffer isn't a subarray, return the underlying ArrayBuffer
+		if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+			return buf.buffer
+		} else if (typeof buf.buffer.slice === 'function') {
+			// Otherwise we need to get a proper copy
+			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+		}
+	}
+
+	if (Buffer.isBuffer(buf)) {
+		// This is the slow version that will work with any Buffer
+		// implementation (even in old browsers)
+		var arrayCopy = new Uint8Array(buf.length)
+		var len = buf.length
+		for (var i = 0; i < len; i++) {
+			arrayCopy[i] = buf[i]
+		}
+		return arrayCopy.buffer
+	} else {
+		throw new Error('Argument must be a Buffer')
+	}
+}
+
+},{"buffer":69}],100:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').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;
+}
+
+},{"buffer":69}],101:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var punycode = require('punycode');
+var util = require('./util');
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+  this.protocol = null;
+  this.slashes = null;
+  this.auth = null;
+  this.host = null;
+  this.port = null;
+  this.hostname = null;
+  this.hash = null;
+  this.search = null;
+  this.query = null;
+  this.pathname = null;
+  this.path = null;
+  this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+    portPattern = /:[0-9]*$/,
+
+    // Special case for a simple path URL
+    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+    // RFC 2396: characters reserved for delimiting URLs.
+    // We actually just auto-escape these.
+    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+    // RFC 2396: characters not allowed for various reasons.
+    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+    autoEscape = ['\''].concat(unwise),
+    // Characters that are never ever allowed in a hostname.
+    // Note that any invalid chars are also handled, but these
+    // are the ones that are *expected* to be seen, so we fast-path
+    // them.
+    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+    hostEndingChars = ['/', '?', '#'],
+    hostnameMaxLen = 255,
+    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+    // protocols that can allow "unsafe" and "unwise" chars.
+    unsafeProtocol = {
+      'javascript': true,
+      'javascript:': true
+    },
+    // protocols that never have a hostname.
+    hostlessProtocol = {
+      'javascript': true,
+      'javascript:': true
+    },
+    // protocols that always contain a // bit.
+    slashedProtocol = {
+      'http': true,
+      'https': true,
+      'ftp': true,
+      'gopher': true,
+      'file': true,
+      'http:': true,
+      'https:': true,
+      'ftp:': true,
+      'gopher:': true,
+      'file:': true
+    },
+    querystring = require('querystring');
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+  if (url && util.isObject(url) && url instanceof Url) return url;
+
+  var u = new Url;
+  u.parse(url, parseQueryString, slashesDenoteHost);
+  return u;
+}
+
+Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+  if (!util.isString(url)) {
+    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+  }
+
+  // Copy chrome, IE, opera backslash-handling behavior.
+  // Back slashes before the query string get converted to forward slashes
+  // See: https://code.google.com/p/chromium/issues/detail?id=25916
+  var queryIndex = url.indexOf('?'),
+      splitter =
+          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+      uSplit = url.split(splitter),
+      slashRegex = /\\/g;
+  uSplit[0] = uSplit[0].replace(slashRegex, '/');
+  url = uSplit.join(splitter);
+
+  var rest = url;
+
+  // trim before proceeding.
+  // This is to support parse stuff like "  http://foo.com  \n"
+  rest = rest.trim();
+
+  if (!slashesDenoteHost && url.split('#').length === 1) {
+    // Try fast path regexp
+    var simplePath = simplePathPattern.exec(rest);
+    if (simplePath) {
+      this.path = rest;
+      this.href = rest;
+      this.pathname = simplePath[1];
+      if (simplePath[2]) {
+        this.search = simplePath[2];
+        if (parseQueryString) {
+          this.query = querystring.parse(this.search.substr(1));
+        } else {
+          this.query = this.search.substr(1);
+        }
+      } else if (parseQueryString) {
+        this.search = '';
+        this.query = {};
+      }
+      return this;
+    }
+  }
+
+  var proto = protocolPattern.exec(rest);
+  if (proto) {
+    proto = proto[0];
+    var lowerProto = proto.toLowerCase();
+    this.protocol = lowerProto;
+    rest = rest.substr(proto.length);
+  }
+
+  // figure out if it's got a host
+  // user@server is *always* interpreted as a hostname, and url
+  // resolution will treat //foo/bar as host=foo,path=bar because that's
+  // how the browser resolves relative URLs.
+  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+    var slashes = rest.substr(0, 2) === '//';
+    if (slashes && !(proto && hostlessProtocol[proto])) {
+      rest = rest.substr(2);
+      this.slashes = true;
+    }
+  }
+
+  if (!hostlessProtocol[proto] &&
+      (slashes || (proto && !slashedProtocol[proto]))) {
+
+    // there's a hostname.
+    // the first instance of /, ?, ;, or # ends the host.
+    //
+    // If there is an @ in the hostname, then non-host chars *are* allowed
+    // to the left of the last @ sign, unless some host-ending character
+    // comes *before* the @-sign.
+    // URLs are obnoxious.
+    //
+    // ex:
+    // http://a@b@c/ => user:a@b host:c
+    // http://a@b?@c => user:a host:c path:/?@c
+
+    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+    // Review our test case against browsers more comprehensively.
+
+    // find the first instance of any hostEndingChars
+    var hostEnd = -1;
+    for (var i = 0; i < hostEndingChars.length; i++) {
+      var hec = rest.indexOf(hostEndingChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+        hostEnd = hec;
+    }
+
+    // at this point, either we have an explicit point where the
+    // auth portion cannot go past, or the last @ char is the decider.
+    var auth, atSign;
+    if (hostEnd === -1) {
+      // atSign can be anywhere.
+      atSign = rest.lastIndexOf('@');
+    } else {
+      // atSign must be in auth portion.
+      // http://a@b/c@d => host:b auth:a path:/c@d
+      atSign = rest.lastIndexOf('@', hostEnd);
+    }
+
+    // Now we have a portion which is definitely the auth.
+    // Pull that off.
+    if (atSign !== -1) {
+      auth = rest.slice(0, atSign);
+      rest = rest.slice(atSign + 1);
+      this.auth = decodeURIComponent(auth);
+    }
+
+    // the host is the remaining to the left of the first non-host char
+    hostEnd = -1;
+    for (var i = 0; i < nonHostChars.length; i++) {
+      var hec = rest.indexOf(nonHostChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+        hostEnd = hec;
+    }
+    // if we still have not hit it, then the entire thing is a host.
+    if (hostEnd === -1)
+      hostEnd = rest.length;
+
+    this.host = rest.slice(0, hostEnd);
+    rest = rest.slice(hostEnd);
+
+    // pull out port.
+    this.parseHost();
+
+    // we've indicated that there is a hostname,
+    // so even if it's empty, it has to be present.
+    this.hostname = this.hostname || '';
+
+    // if hostname begins with [ and ends with ]
+    // assume that it's an IPv6 address.
+    var ipv6Hostname = this.hostname[0] === '[' &&
+        this.hostname[this.hostname.length - 1] === ']';
+
+    // validate a little.
+    if (!ipv6Hostname) {
+      var hostparts = this.hostname.split(/\./);
+      for (var i = 0, l = hostparts.length; i < l; i++) {
+        var part = hostparts[i];
+        if (!part) continue;
+        if (!part.match(hostnamePartPattern)) {
+          var newpart = '';
+          for (var j = 0, k = part.length; j < k; j++) {
+            if (part.charCodeAt(j) > 127) {
+              // we replace non-ASCII char with a temporary placeholder
+              // we need this to make sure size of hostname is not
+              // broken by replacing non-ASCII by nothing
+              newpart += 'x';
+            } else {
+              newpart += part[j];
+            }
+          }
+          // we test again with ASCII char only
+          if (!newpart.match(hostnamePartPattern)) {
+            var validParts = hostparts.slice(0, i);
+            var notHost = hostparts.slice(i + 1);
+            var bit = part.match(hostnamePartStart);
+            if (bit) {
+              validParts.push(bit[1]);
+              notHost.unshift(bit[2]);
+            }
+            if (notHost.length) {
+              rest = '/' + notHost.join('.') + rest;
+            }
+            this.hostname = validParts.join('.');
+            break;
+          }
+        }
+      }
+    }
+
+    if (this.hostname.length > hostnameMaxLen) {
+      this.hostname = '';
+    } else {
+      // hostnames are always lower case.
+      this.hostname = this.hostname.toLowerCase();
+    }
+
+    if (!ipv6Hostname) {
+      // IDNA Support: Returns a punycoded representation of "domain".
+      // It only converts parts of the domain name that
+      // have non-ASCII characters, i.e. it doesn't matter if
+      // you call it with a domain that already is ASCII-only.
+      this.hostname = punycode.toASCII(this.hostname);
+    }
+
+    var p = this.port ? ':' + this.port : '';
+    var h = this.hostname || '';
+    this.host = h + p;
+    this.href += this.host;
+
+    // strip [ and ] from the hostname
+    // the host field still retains them, though
+    if (ipv6Hostname) {
+      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+      if (rest[0] !== '/') {
+        rest = '/' + rest;
+      }
+    }
+  }
+
+  // now rest is set to the post-host stuff.
+  // chop off any delim chars.
+  if (!unsafeProtocol[lowerProto]) {
+
+    // First, make 100% sure that any "autoEscape" chars get
+    // escaped, even if encodeURIComponent doesn't think they
+    // need to be.
+    for (var i = 0, l = autoEscape.length; i < l; i++) {
+      var ae = autoEscape[i];
+      if (rest.indexOf(ae) === -1)
+        continue;
+      var esc = encodeURIComponent(ae);
+      if (esc === ae) {
+        esc = escape(ae);
+      }
+      rest = rest.split(ae).join(esc);
+    }
+  }
+
+
+  // chop off from the tail first.
+  var hash = rest.indexOf('#');
+  if (hash !== -1) {
+    // got a fragment string.
+    this.hash = rest.substr(hash);
+    rest = rest.slice(0, hash);
+  }
+  var qm = rest.indexOf('?');
+  if (qm !== -1) {
+    this.search = rest.substr(qm);
+    this.query = rest.substr(qm + 1);
+    if (parseQueryString) {
+      this.query = querystring.parse(this.query);
+    }
+    rest = rest.slice(0, qm);
+  } else if (parseQueryString) {
+    // no query string, but parseQueryString still requested
+    this.search = '';
+    this.query = {};
+  }
+  if (rest) this.pathname = rest;
+  if (slashedProtocol[lowerProto] &&
+      this.hostname && !this.pathname) {
+    this.pathname = '/';
+  }
+
+  //to support http.request
+  if (this.pathname || this.search) {
+    var p = this.pathname || '';
+    var s = this.search || '';
+    this.path = p + s;
+  }
+
+  // finally, reconstruct the href based on what has been validated.
+  this.href = this.format();
+  return this;
+};
+
+// format a parsed object into a url string
+function urlFormat(obj) {
+  // ensure it's an object, and not a string url.
+  // If it's an obj, this is a no-op.
+  // this way, you can call url_format() on strings
+  // to clean up potentially wonky urls.
+  if (util.isString(obj)) obj = urlParse(obj);
+  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+  return obj.format();
+}
+
+Url.prototype.format = function() {
+  var auth = this.auth || '';
+  if (auth) {
+    auth = encodeURIComponent(auth);
+    auth = auth.replace(/%3A/i, ':');
+    auth += '@';
+  }
+
+  var protocol = this.protocol || '',
+      pathname = this.pathname || '',
+      hash = this.hash || '',
+      host = false,
+      query = '';
+
+  if (this.host) {
+    host = auth + this.host;
+  } else if (this.hostname) {
+    host = auth + (this.hostname.indexOf(':') === -1 ?
+        this.hostname :
+        '[' + this.hostname + ']');
+    if (this.port) {
+      host += ':' + this.port;
+    }
+  }
+
+  if (this.query &&
+      util.isObject(this.query) &&
+      Object.keys(this.query).length) {
+    query = querystring.stringify(this.query);
+  }
+
+  var search = this.search || (query && ('?' + query)) || '';
+
+  if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
+  // unless they had them to begin with.
+  if (this.slashes ||
+      (!protocol || slashedProtocol[protocol]) && host !== false) {
+    host = '//' + (host || '');
+    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+  } else if (!host) {
+    host = '';
+  }
+
+  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+  if (search && search.charAt(0) !== '?') search = '?' + search;
+
+  pathname = pathname.replace(/[?#]/g, function(match) {
+    return encodeURIComponent(match);
+  });
+  search = search.replace('#', '%23');
+
+  return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+  return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function(relative) {
+  return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+  if (!source) return relative;
+  return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function(relative) {
+  if (util.isString(relative)) {
+    var rel = new Url();
+    rel.parse(relative, false, true);
+    relative = rel;
+  }
+
+  var result = new Url();
+  var tkeys = Object.keys(this);
+  for (var tk = 0; tk < tkeys.length; tk++) {
+    var tkey = tkeys[tk];
+    result[tkey] = this[tkey];
+  }
+
+  // hash is always overridden, no matter what.
+  // even href="" will remove it.
+  result.hash = relative.hash;
+
+  // if the relative url is empty, then there's nothing left to do here.
+  if (relative.href === '') {
+    result.href = result.format();
+    return result;
+  }
+
+  // hrefs like //foo/bar always cut to the protocol.
+  if (relative.slashes && !relative.protocol) {
+    // take everything except the protocol from relative
+    var rkeys = Object.keys(relative);
+    for (var rk = 0; rk < rkeys.length; rk++) {
+      var rkey = rkeys[rk];
+      if (rkey !== 'protocol')
+        result[rkey] = relative[rkey];
+    }
+
+    //urlParse appends trailing / to urls like http://www.example.com
+    if (slashedProtocol[result.protocol] &&
+        result.hostname && !result.pathname) {
+      result.path = result.pathname = '/';
+    }
+
+    result.href = result.format();
+    return result;
+  }
+
+  if (relative.protocol && relative.protocol !== result.protocol) {
+    // if it's a known url protocol, then changing
+    // the protocol does weird things
+    // first, if it's not file:, then we MUST have a host,
+    // and if there was a path
+    // to begin with, then we MUST have a path.
+    // if it is file:, then the host is dropped,
+    // because that's known to be hostless.
+    // anything else is assumed to be absolute.
+    if (!slashedProtocol[relative.protocol]) {
+      var keys = Object.keys(relative);
+      for (var v = 0; v < keys.length; v++) {
+        var k = keys[v];
+        result[k] = relative[k];
+      }
+      result.href = result.format();
+      return result;
+    }
+
+    result.protocol = relative.protocol;
+    if (!relative.host && !hostlessProtocol[relative.protocol]) {
+      var relPath = (relative.pathname || '').split('/');
+      while (relPath.length && !(relative.host = relPath.shift()));
+      if (!relative.host) relative.host = '';
+      if (!relative.hostname) relative.hostname = '';
+      if (relPath[0] !== '') relPath.unshift('');
+      if (relPath.length < 2) relPath.unshift('');
+      result.pathname = relPath.join('/');
+    } else {
+      result.pathname = relative.pathname;
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    result.host = relative.host || '';
+    result.auth = relative.auth;
+    result.hostname = relative.hostname || relative.host;
+    result.port = relative.port;
+    // to support http.request
+    if (result.pathname || result.search) {
+      var p = result.pathname || '';
+      var s = result.search || '';
+      result.path = p + s;
+    }
+    result.slashes = result.slashes || relative.slashes;
+    result.href = result.format();
+    return result;
+  }
+
+  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+      isRelAbs = (
+          relative.host ||
+          relative.pathname && relative.pathname.charAt(0) === '/'
+      ),
+      mustEndAbs = (isRelAbs || isSourceAbs ||
+                    (result.host && relative.pathname)),
+      removeAllDots = mustEndAbs,
+      srcPath = result.pathname && result.pathname.split('/') || [],
+      relPath = relative.pathname && relative.pathname.split('/') || [],
+      psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+  // if the url is a non-slashed url, then relative
+  // links like ../.. should be able
+  // to crawl up to the hostname, as well.  This is strange.
+  // result.protocol has already been set by now.
+  // Later on, put the first path part into the host field.
+  if (psychotic) {
+    result.hostname = '';
+    result.port = null;
+    if (result.host) {
+      if (srcPath[0] === '') srcPath[0] = result.host;
+      else srcPath.unshift(result.host);
+    }
+    result.host = '';
+    if (relative.protocol) {
+      relative.hostname = null;
+      relative.port = null;
+      if (relative.host) {
+        if (relPath[0] === '') relPath[0] = relative.host;
+        else relPath.unshift(relative.host);
+      }
+      relative.host = null;
+    }
+    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+  }
+
+  if (isRelAbs) {
+    // it's absolute.
+    result.host = (relative.host || relative.host === '') ?
+                  relative.host : result.host;
+    result.hostname = (relative.hostname || relative.hostname === '') ?
+                      relative.hostname : result.hostname;
+    result.search = relative.search;
+    result.query = relative.query;
+    srcPath = relPath;
+    // fall through to the dot-handling below.
+  } else if (relPath.length) {
+    // it's relative
+    // throw away the existing file, and take the new path instead.
+    if (!srcPath) srcPath = [];
+    srcPath.pop();
+    srcPath = srcPath.concat(relPath);
+    result.search = relative.search;
+    result.query = relative.query;
+  } else if (!util.isNullOrUndefined(relative.search)) {
+    // just pull out the search.
+    // like href='?foo'.
+    // Put this after the other two cases because it simplifies the booleans
+    if (psychotic) {
+      result.hostname = result.host = srcPath.shift();
+      //occationaly the auth can get stuck only in host
+      //this especially happens in cases like
+      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                       result.host.split('@') : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    //to support http.request
+    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+      result.path = (result.pathname ? result.pathname : '') +
+                    (result.search ? result.search : '');
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  if (!srcPath.length) {
+    // no path at all.  easy.
+    // we've already handled the other stuff above.
+    result.pathname = null;
+    //to support http.request
+    if (result.search) {
+      result.path = '/' + result.search;
+    } else {
+      result.path = null;
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  // if a url ENDs in . or .., then it must get a trailing slash.
+  // however, if it ends in anything else non-slashy,
+  // then it must NOT get a trailing slash.
+  var last = srcPath.slice(-1)[0];
+  var hasTrailingSlash = (
+      (result.host || relative.host || srcPath.length > 1) &&
+      (last === '.' || last === '..') || last === '');
+
+  // strip single dots, resolve double dots to parent dir
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = srcPath.length; i >= 0; i--) {
+    last = srcPath[i];
+    if (last === '.') {
+      srcPath.splice(i, 1);
+    } else if (last === '..') {
+      srcPath.splice(i, 1);
+      up++;
+    } else if (up) {
+      srcPath.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (!mustEndAbs && !removeAllDots) {
+    for (; up--; up) {
+      srcPath.unshift('..');
+    }
+  }
+
+  if (mustEndAbs && srcPath[0] !== '' &&
+      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+    srcPath.unshift('');
+  }
+
+  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+    srcPath.push('');
+  }
+
+  var isAbsolute = srcPath[0] === '' ||
+      (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+  // put the host back
+  if (psychotic) {
+    result.hostname = result.host = isAbsolute ? '' :
+                                    srcPath.length ? srcPath.shift() : '';
+    //occationaly the auth can get stuck only in host
+    //this especially happens in cases like
+    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+    var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                     result.host.split('@') : false;
+    if (authInHost) {
+      result.auth = authInHost.shift();
+      result.host = result.hostname = authInHost.shift();
+    }
+  }
+
+  mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+  if (mustEndAbs && !isAbsolute) {
+    srcPath.unshift('');
+  }
+
+  if (!srcPath.length) {
+    result.pathname = null;
+    result.path = null;
+  } else {
+    result.pathname = srcPath.join('/');
+  }
+
+  //to support request.http
+  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+    result.path = (result.pathname ? result.pathname : '') +
+                  (result.search ? result.search : '');
+  }
+  result.auth = relative.auth || result.auth;
+  result.slashes = result.slashes || relative.slashes;
+  result.href = result.format();
+  return result;
+};
+
+Url.prototype.parseHost = function() {
+  var host = this.host;
+  var port = portPattern.exec(host);
+  if (port) {
+    port = port[0];
+    if (port !== ':') {
+      this.port = port.substr(1);
+    }
+    host = host.substr(0, host.length - port.length);
+  }
+  if (host) this.hostname = host;
+};
+
+},{"./util":102,"punycode":78,"querystring":81}],102:[function(require,module,exports){
+'use strict';
+
+module.exports = {
+  isString: function(arg) {
+    return typeof(arg) === 'string';
+  },
+  isObject: function(arg) {
+    return typeof(arg) === 'object' && arg !== null;
+  },
+  isNull: function(arg) {
+    return arg === null;
+  },
+  isNullOrUndefined: function(arg) {
+    return arg == null;
+  }
+};
+
+},{}],103:[function(require,module,exports){
+module.exports = extend
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend() {
+    var target = {}
+
+    for (var i = 0; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (hasOwnProperty.call(source, key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}
+
+},{}],104:[function(require,module,exports){
+arguments[4][3][0].apply(exports,arguments)
+},{"_process":77,"dup":3}],105:[function(require,module,exports){
+//     Underscore.js 1.5.2
+//     http://underscorejs.org
+//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+  // Baseline setup
+  // --------------
+
+  // Establish the root object, `window` in the browser, or `exports` on the server.
+  var root = this;
+
+  // Save the previous value of the `_` variable.
+  var previousUnderscore = root._;
+
+  // Establish the object that gets returned to break out of a loop iteration.
+  var breaker = {};
+
+  // Save bytes in the minified (but not gzipped) version:
+  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+  // Create quick reference variables for speed access to core prototypes.
+  var
+    push             = ArrayProto.push,
+    slice            = ArrayProto.slice,
+    concat           = ArrayProto.concat,
+    toString         = ObjProto.toString,
+    hasOwnProperty   = ObjProto.hasOwnProperty;
+
+  // All **ECMAScript 5** native function implementations that we hope to use
+  // are declared here.
+  var
+    nativeForEach      = ArrayProto.forEach,
+    nativeMap          = ArrayProto.map,
+    nativeReduce       = ArrayProto.reduce,
+    nativeReduceRight  = ArrayProto.reduceRight,
+    nativeFilter       = ArrayProto.filter,
+    nativeEvery        = ArrayProto.every,
+    nativeSome         = ArrayProto.some,
+    nativeIndexOf      = ArrayProto.indexOf,
+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
+    nativeIsArray      = Array.isArray,
+    nativeKeys         = Object.keys,
+    nativeBind         = FuncProto.bind;
+
+  // Create a safe reference to the Underscore object for use below.
+  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
+
+  // Export the Underscore object for **Node.js**, with
+  // backwards-compatibility for the old `require()` API. If we're in
+  // the browser, add `_` as a global object via a string identifier,
+  // for Closure Compiler "advanced" mode.
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = _;
+    }
+    exports._ = _;
+  } else {
+    root._ = _;
+  }
+
+  // Current version.
+  _.VERSION = '1.5.2';
+
+  // Collection Functions
+  // --------------------
+
+  // The cornerstone, an `each` implementation, aka `forEach`.
+  // Handles objects with the built-in `forEach`, arrays, and raw objects.
+  // Delegates to **ECMAScript 5**'s native `forEach` if available.
+  var each = _.each = _.forEach = function(obj, iterator, context) {
+    if (obj == null) return;
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (var i = 0, length = obj.length; i < length; i++) {
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
+      }
+    } else {
+      var keys = _.keys(obj);
+      for (var i = 0, length = keys.length; i < length; i++) {
+        if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
+      }
+    }
+  };
+
+  // Return the results of applying the iterator to each element.
+  // Delegates to **ECMAScript 5**'s native `map` if available.
+  _.map = _.collect = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+    each(obj, function(value, index, list) {
+      results.push(iterator.call(context, value, index, list));
+    });
+    return results;
+  };
+
+  var reduceError = 'Reduce of empty array with no initial value';
+
+  // **Reduce** builds up a single result from a list of values, aka `inject`,
+  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduce && obj.reduce === nativeReduce) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+    }
+    each(obj, function(value, index, list) {
+      if (!initial) {
+        memo = value;
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, value, index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // The right-associative version of reduce, also known as `foldr`.
+  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+    }
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // Return the first value which passes a truth test. Aliased as `detect`.
+  _.find = _.detect = function(obj, iterator, context) {
+    var result;
+    any(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) {
+        result = value;
+        return true;
+      }
+    });
+    return result;
+  };
+
+  // Return all the elements that pass a truth test.
+  // Delegates to **ECMAScript 5**'s native `filter` if available.
+  // Aliased as `select`.
+  _.filter = _.select = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+    each(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) results.push(value);
+    });
+    return results;
+  };
+
+  // Return all the elements for which a truth test fails.
+  _.reject = function(obj, iterator, context) {
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
+  };
+
+  // Determine whether all of the elements match a truth test.
+  // Delegates to **ECMAScript 5**'s native `every` if available.
+  // Aliased as `all`.
+  _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = true;
+    if (obj == null) return result;
+    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+    each(obj, function(value, index, list) {
+      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if at least one element in the object matches a truth test.
+  // Delegates to **ECMAScript 5**'s native `some` if available.
+  // Aliased as `any`.
+  var any = _.some = _.any = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = false;
+    if (obj == null) return result;
+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+    each(obj, function(value, index, list) {
+      if (result || (result = iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+    return any(obj, function(value) {
+      return value === target;
+    });
+  };
+
+  // Invoke a method (with arguments) on every item in a collection.
+  _.invoke = function(obj, method) {
+    var args = slice.call(arguments, 2);
+    var isFunc = _.isFunction(method);
+    return _.map(obj, function(value) {
+      return (isFunc ? method : value[method]).apply(value, args);
+    });
+  };
+
+  // Convenience version of a common use case of `map`: fetching a property.
+  _.pluck = function(obj, key) {
+    return _.map(obj, function(value){ return value[key]; });
+  };
+
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // containing specific `key:value` pairs.
+  _.where = function(obj, attrs, first) {
+    if (_.isEmpty(attrs)) return first ? void 0 : [];
+    return _[first ? 'find' : 'filter'](obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Convenience version of a common use case of `find`: getting the first object
+  // containing specific `key:value` pairs.
+  _.findWhere = function(obj, attrs) {
+    return _.where(obj, attrs, true);
+  };
+
+  // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
+  _.max = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return -Infinity;
+    var result = {computed : -Infinity, value: -Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed > result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Return the minimum element (or element-based computation).
+  _.min = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return Infinity;
+    var result = {computed : Infinity, value: Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed < result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Shuffle an array, using the modern version of the 
+  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
+  _.shuffle = function(obj) {
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
+    });
+    return shuffled;
+  };
+
+  // Sample **n** random values from an array.
+  // If **n** is not specified, returns a single random element from the array.
+  // The internal `guard` argument allows it to work with `map`.
+  _.sample = function(obj, n, guard) {
+    if (arguments.length < 2 || guard) {
+      return obj[_.random(obj.length - 1)];
+    }
+    return _.shuffle(obj).slice(0, Math.max(0, n));
+  };
+
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
+  // Sort the object's values by a criterion produced by an iterator.
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
+    return _.pluck(_.map(obj, function(value, index, list) {
+      return {
+        value: value,
+        index: index,
+        criteria: iterator.call(context, value, index, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index - right.index;
+    }), 'value');
+  };
+
+  // An internal function used for aggregate "group by" operations.
+  var group = function(behavior) {
+    return function(obj, value, context) {
+      var result = {};
+      var iterator = value == null ? _.identity : lookupIterator(value);
+      each(obj, function(value, index) {
+        var key = iterator.call(context, value, index, obj);
+        behavior(result, key, value);
+      });
+      return result;
+    };
+  };
+
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = group(function(result, key, value) {
+    (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+  });
+
+  // Indexes the object's values by a criterion, similar to `groupBy`, but for
+  // when you know that your index values will be unique.
+  _.indexBy = group(function(result, key, value) {
+    result[key] = value;
+  });
+
+  // Counts instances of an object that group by a certain criterion. Pass
+  // either a string attribute to count by, or a function that returns the
+  // criterion.
+  _.countBy = group(function(result, key) {
+    _.has(result, key) ? result[key]++ : result[key] = 1;
+  });
+
+  // Use a comparator function to figure out the smallest index at which
+  // an object should be inserted so as to maintain order. Uses binary search.
+  _.sortedIndex = function(array, obj, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
+    var low = 0, high = array.length;
+    while (low < high) {
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+    }
+    return low;
+  };
+
+  // Safely create a real, live array from anything iterable.
+  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
+    return _.values(obj);
+  };
+
+  // Return the number of elements in an object.
+  _.size = function(obj) {
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+  };
+
+  // Array Functions
+  // ---------------
+
+  // Get the first element of an array. Passing **n** will return the first N
+  // values in the array. Aliased as `head` and `take`. The **guard** check
+  // allows it to work with `_.map`.
+  _.first = _.head = _.take = function(array, n, guard) {
+    if (array == null) return void 0;
+    return (n == null) || guard ? array[0] : slice.call(array, 0, n);
+  };
+
+  // Returns everything but the last entry of the array. Especially useful on
+  // the arguments object. Passing **n** will return all the values in
+  // the array, excluding the last N. The **guard** check allows it to work with
+  // `_.map`.
+  _.initial = function(array, n, guard) {
+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+  };
+
+  // Get the last element of an array. Passing **n** will return the last N
+  // values in the array. The **guard** check allows it to work with `_.map`.
+  _.last = function(array, n, guard) {
+    if (array == null) return void 0;
+    if ((n == null) || guard) {
+      return array[array.length - 1];
+    } else {
+      return slice.call(array, Math.max(array.length - n, 0));
+    }
+  };
+
+  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+  // Especially useful on the arguments object. Passing an **n** will return
+  // the rest N values in the array. The **guard**
+  // check allows it to work with `_.map`.
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
+  };
+
+  // Trim out all falsy values from an array.
+  _.compact = function(array) {
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    if (shallow && _.every(input, _.isArray)) {
+      return concat.apply(output, input);
+    }
+    each(input, function(value) {
+      if (_.isArray(value) || _.isArguments(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
+  };
+
+  // Flatten out an array, either recursively (by default), or just one level.
+  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, []);
+  };
+
+  // Return a version of the array that does not contain the specified value(s).
+  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
+
+  // Produce a duplicate-free version of the array. If the array has already
+  // been sorted, you have the option of using a faster algorithm.
+  // Aliased as `unique`.
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
+      }
+    });
+    return results;
+  };
+
+  // Produce an array that contains the union: each distinct element from all of
+  // the passed-in arrays.
+  _.union = function() {
+    return _.uniq(_.flatten(arguments, true));
+  };
+
+  // Produce an array that contains every item shared between all the
+  // passed-in arrays.
+  _.intersection = function(array) {
+    var rest = slice.call(arguments, 1);
+    return _.filter(_.uniq(array), function(item) {
+      return _.every(rest, function(other) {
+        return _.indexOf(other, item) >= 0;
+      });
+    });
+  };
+
+  // Take the difference between one array and a number of other arrays.
+  // Only the elements present in just the first array will remain.
+  _.difference = function(array) {
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
+  };
+
+  // Zip together multiple lists into a single array -- elements that share
+  // an index go together.
+  _.zip = function() {
+    var length = _.max(_.pluck(arguments, "length").concat(0));
+    var results = new Array(length);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(arguments, '' + i);
+    }
+    return results;
+  };
+
+  // Converts lists into objects. Pass either a single array of `[key, value]`
+  // pairs, or two parallel arrays of the same length -- one of keys, and one of
+  // the corresponding values.
+  _.object = function(list, values) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, length = list.length; i < length; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
+  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+  // we need this function. Return the position of the first occurrence of an
+  // item in an array, or -1 if the item is not included in the array.
+  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+  // If the array is large and already in sort order, pass `true`
+  // for **isSorted** to use binary search.
+  _.indexOf = function(array, item, isSorted) {
+    if (array == null) return -1;
+    var i = 0, length = array.length;
+    if (isSorted) {
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
+    }
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < length; i++) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+  _.lastIndexOf = function(array, item, from) {
+    if (array == null) return -1;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](http://docs.python.org/library/functions.html#range).
+  _.range = function(start, stop, step) {
+    if (arguments.length <= 1) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = arguments[2] || 1;
+
+    var length = Math.max(Math.ceil((stop - start) / step), 0);
+    var idx = 0;
+    var range = new Array(length);
+
+    while(idx < length) {
+      range[idx++] = start;
+      start += step;
+    }
+
+    return range;
+  };
+
+  // Function (ahem) Functions
+  // ------------------
+
+  // Reusable constructor function for prototype setting.
+  var ctor = function(){};
+
+  // Create a function bound to a given object (assigning `this`, and arguments,
+  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+  // available.
+  _.bind = function(func, context) {
+    var args, bound;
+    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+    if (!_.isFunction(func)) throw new TypeError;
+    args = slice.call(arguments, 2);
+    return bound = function() {
+      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+      ctor.prototype = func.prototype;
+      var self = new ctor;
+      ctor.prototype = null;
+      var result = func.apply(self, args.concat(slice.call(arguments)));
+      if (Object(result) === result) return result;
+      return self;
+    };
+  };
+
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context.
+  _.partial = function(func) {
+    var args = slice.call(arguments, 1);
+    return function() {
+      return func.apply(this, args.concat(slice.call(arguments)));
+    };
+  };
+
+  // Bind all of an object's methods to that object. Useful for ensuring that
+  // all callbacks defined on an object belong to it.
+  _.bindAll = function(obj) {
+    var funcs = slice.call(arguments, 1);
+    if (funcs.length === 0) throw new Error("bindAll must be passed function names");
+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+    return obj;
+  };
+
+  // Memoize an expensive function by storing its results.
+  _.memoize = function(func, hasher) {
+    var memo = {};
+    hasher || (hasher = _.identity);
+    return function() {
+      var key = hasher.apply(this, arguments);
+      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+    };
+  };
+
+  // Delays a function for the given number of milliseconds, and then calls
+  // it with the arguments supplied.
+  _.delay = function(func, wait) {
+    var args = slice.call(arguments, 2);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
+  };
+
+  // Defers a function, scheduling it to run after the current call stack has
+  // cleared.
+  _.defer = function(func) {
+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+  };
+
+  // Returns a function, that, when invoked, will only be triggered at most once
+  // during a given window of time. Normally, the throttled function will run
+  // as much as it can, without ever going more than once per `wait` duration;
+  // but if you'd like to disable the execution on the leading edge, pass
+  // `{leading: false}`. To disable execution on the trailing edge, ditto.
+  _.throttle = function(func, wait, options) {
+    var context, args, result;
+    var timeout = null;
+    var previous = 0;
+    options || (options = {});
+    var later = function() {
+      previous = options.leading === false ? 0 : new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
+    return function() {
+      var now = new Date;
+      if (!previous && options.leading === false) previous = now;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
+        timeout = null;
+        previous = now;
+        result = func.apply(context, args);
+      } else if (!timeout && options.trailing !== false) {
+        timeout = setTimeout(later, remaining);
+      }
+      return result;
+    };
+  };
+
+  // Returns a function, that, as long as it continues to be invoked, will not
+  // be triggered. The function will be called after it stops being called for
+  // N milliseconds. If `immediate` is passed, trigger the function on the
+  // leading edge, instead of the trailing.
+  _.debounce = function(func, wait, immediate) {
+    var timeout, args, context, timestamp, result;
+    return function() {
+      context = this;
+      args = arguments;
+      timestamp = new Date();
+      var later = function() {
+        var last = (new Date()) - timestamp;
+        if (last < wait) {
+          timeout = setTimeout(later, wait - last);
+        } else {
+          timeout = null;
+          if (!immediate) result = func.apply(context, args);
+        }
+      };
+      var callNow = immediate && !timeout;
+      if (!timeout) {
+        timeout = setTimeout(later, wait);
+      }
+      if (callNow) result = func.apply(context, args);
+      return result;
+    };
+  };
+
+  // Returns a function that will be executed at most one time, no matter how
+  // often you call it. Useful for lazy initialization.
+  _.once = function(func) {
+    var ran = false, memo;
+    return function() {
+      if (ran) return memo;
+      ran = true;
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
+    };
+  };
+
+  // Returns the first function passed as an argument to the second,
+  // allowing you to adjust arguments, run code before and after, and
+  // conditionally execute the original function.
+  _.wrap = function(func, wrapper) {
+    return function() {
+      var args = [func];
+      push.apply(args, arguments);
+      return wrapper.apply(this, args);
+    };
+  };
+
+  // Returns a function that is the composition of a list of functions, each
+  // consuming the return value of the function that follows.
+  _.compose = function() {
+    var funcs = arguments;
+    return function() {
+      var args = arguments;
+      for (var i = funcs.length - 1; i >= 0; i--) {
+        args = [funcs[i].apply(this, args)];
+      }
+      return args[0];
+    };
+  };
+
+  // Returns a function that will only be executed after being called N times.
+  _.after = function(times, func) {
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
+
+  // Object Functions
+  // ----------------
+
+  // Retrieve the names of an object's properties.
+  // Delegates to **ECMAScript 5**'s native `Object.keys`
+  _.keys = nativeKeys || function(obj) {
+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
+    var keys = [];
+    for (var key in obj) if (_.has(obj, key)) keys.push(key);
+    return keys;
+  };
+
+  // Retrieve the values of an object's properties.
+  _.values = function(obj) {
+    var keys = _.keys(obj);
+    var length = keys.length;
+    var values = new Array(length);
+    for (var i = 0; i < length; i++) {
+      values[i] = obj[keys[i]];
+    }
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var keys = _.keys(obj);
+    var length = keys.length;
+    var pairs = new Array(length);
+    for (var i = 0; i < length; i++) {
+      pairs[i] = [keys[i], obj[keys[i]]];
+    }
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    var keys = _.keys(obj);
+    for (var i = 0, length = keys.length; i < length; i++) {
+      result[obj[keys[i]]] = keys[i];
+    }
+    return result;
+  };
+
+  // Return a sorted list of the function names available on the object.
+  // Aliased as `methods`
+  _.functions = _.methods = function(obj) {
+    var names = [];
+    for (var key in obj) {
+      if (_.isFunction(obj[key])) names.push(key);
+    }
+    return names.sort();
+  };
+
+  // Extend a given object with all the properties in passed-in object(s).
+  _.extend = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
+
+  // Fill in a given object with default properties.
+  _.defaults = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] === void 0) obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Create a (shallow-cloned) duplicate of an object.
+  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
+
+  // Invokes interceptor with the obj, and then returns obj.
+  // The primary purpose of this method is to "tap into" a method chain, in
+  // order to perform operations on intermediate results within the chain.
+  _.tap = function(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  };
+
+  // Internal recursive comparison function for `isEqual`.
+  var eq = function(a, b, aStack, bStack) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+    if (a === b) return a !== 0 || 1 / a == 1 / b;
+    // A strict comparison is necessary because `null == undefined`.
+    if (a == null || b == null) return a === b;
+    // Unwrap any wrapped objects.
+    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
+    // Compare `[[Class]]` names.
+    var className = toString.call(a);
+    if (className != toString.call(b)) return false;
+    switch (className) {
+      // Strings, numbers, dates, and booleans are compared by value.
+      case '[object String]':
+        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+        // equivalent to `new String("5")`.
+        return a == String(b);
+      case '[object Number]':
+        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+        // other numeric values.
+        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+      case '[object Date]':
+      case '[object Boolean]':
+        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+        // millisecond representations. Note that invalid dates with millisecond representations
+        // of `NaN` are not equivalent.
+        return +a == +b;
+      // RegExps are compared by their source patterns and flags.
+      case '[object RegExp]':
+        return a.source == b.source &&
+               a.global == b.global &&
+               a.multiline == b.multiline &&
+               a.ignoreCase == b.ignoreCase;
+    }
+    if (typeof a != 'object' || typeof b != 'object') return false;
+    // Assume equality for cyclic structures. The algorithm for detecting cyclic
+    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+    var length = aStack.length;
+    while (length--) {
+      // Linear search. Performance is inversely proportional to the number of
+      // unique nested structures.
+      if (aStack[length] == a) return bStack[length] == b;
+    }
+    // Objects with different constructors are not equivalent, but `Object`s
+    // from different frames are.
+    var aCtor = a.constructor, bCtor = b.constructor;
+    if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                             _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+      return false;
+    }
+    // Add the first object to the stack of traversed objects.
+    aStack.push(a);
+    bStack.push(b);
+    var size = 0, result = true;
+    // Recursively compare objects and arrays.
+    if (className == '[object Array]') {
+      // Compare array lengths to determine if a deep comparison is necessary.
+      size = a.length;
+      result = size == b.length;
+      if (result) {
+        // Deep compare the contents, ignoring non-numeric properties.
+        while (size--) {
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+        }
+      }
+    } else {
+      // Deep compare objects.
+      for (var key in a) {
+        if (_.has(a, key)) {
+          // Count the expected number of properties.
+          size++;
+          // Deep compare each member.
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+        }
+      }
+      // Ensure that both objects contain the same number of properties.
+      if (result) {
+        for (key in b) {
+          if (_.has(b, key) && !(size--)) break;
+        }
+        result = !size;
+      }
+    }
+    // Remove the first object from the stack of traversed objects.
+    aStack.pop();
+    bStack.pop();
+    return result;
+  };
+
+  // Perform a deep comparison to check if two objects are equal.
+  _.isEqual = function(a, b) {
+    return eq(a, b, [], []);
+  };
+
+  // Is a given array, string, or object empty?
+  // An "empty" object has no enumerable own-properties.
+  _.isEmpty = function(obj) {
+    if (obj == null) return true;
+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+    for (var key in obj) if (_.has(obj, key)) return false;
+    return true;
+  };
+
+  // Is a given value a DOM element?
+  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
+
+  // Is a given value an array?
+  // Delegates to ECMA5's native Array.isArray
+  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) == '[object Array]';
+  };
+
+  // Is a given variable an object?
+  _.isObject = function(obj) {
+    return obj === Object(obj);
+  };
+
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
+  if (!_.isArguments(arguments)) {
+    _.isArguments = function(obj) {
+      return !!(obj && _.has(obj, 'callee'));
+    };
+  }
+
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
+
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return isFinite(obj) && !isNaN(parseFloat(obj));
+  };
+
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj != +obj;
+  };
+
+  // Is a given value a boolean?
+  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+  };
+
+  // Is a given value equal to null?
+  _.isNull = function(obj) {
+    return obj === null;
+  };
+
+  // Is a given variable undefined?
+  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+
+  // Shortcut function for checking if an object has a given property directly
+  // on itself (in other words, not on a prototype).
+  _.has = function(obj, key) {
+    return hasOwnProperty.call(obj, key);
+  };
+
+  // Utility Functions
+  // -----------------
+
+  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+  // previous owner. Returns a reference to the Underscore object.
+  _.noConflict = function() {
+    root._ = previousUnderscore;
+    return this;
+  };
+
+  // Keep the identity function around for default iterators.
+  _.identity = function(value) {
+    return value;
+  };
+
+  // Run a function **n** times.
+  _.times = function(n, iterator, context) {
+    var accum = Array(Math.max(0, n));
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
+  };
+
+  // Return a random integer between min and max (inclusive).
+  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + Math.floor(Math.random() * (max - min + 1));
+  };
+
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
+
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
+  // If the value of the named `property` is a function then invoke it with the
+  // `object` as context; otherwise, return it.
+  _.result = function(object, property) {
+    if (object == null) return void 0;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
+  // Add your own custom functions to the Underscore object.
+  _.mixin = function(obj) {
+    each(_.functions(obj), function(name) {
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
+    });
+  };
+
+  // Generate a unique integer id (unique within the entire client session).
+  // Useful for temporary DOM ids.
+  var idCounter = 0;
+  _.uniqueId = function(prefix) {
+    var id = ++idCounter + '';
+    return prefix ? prefix + id : id;
+  };
+
+  // By default, Underscore uses ERB-style template delimiters, change the
+  // following template settings to use alternative delimiters.
+  _.templateSettings = {
+    evaluate    : /<%([\s\S]+?)%>/g,
+    interpolate : /<%=([\s\S]+?)%>/g,
+    escape      : /<%-([\s\S]+?)%>/g
+  };
+
+  // When customizing `templateSettings`, if you don't want to define an
+  // interpolation, evaluation or escaping regex, we need one that is
+  // guaranteed not to match.
+  var noMatch = /(.)^/;
+
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+  // JavaScript micro-templating, similar to John Resig's implementation.
+  // Underscore templating handles arbitrary delimiters, preserves whitespace,
+  // and correctly escapes quotes within interpolated code.
+  _.template = function(text, data, settings) {
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
+
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
+  };
+
+  // Add a "chain" function, which will delegate to the wrapper.
+  _.chain = function(obj) {
+    return _(obj).chain();
+  };
+
+  // OOP
+  // ---------------
+  // If Underscore is called as a function, it returns a wrapped object that
+  // can be used OO-style. This wrapper holds altered versions of all the
+  // underscore functions. Wrapped objects may be chained.
+
+  // Helper function to continue chaining intermediate results.
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
+  };
+
+  // Add all of the Underscore functions to the wrapper object.
+  _.mixin(_);
+
+  // Add all mutator Array functions to the wrapper.
+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
+    };
+  });
+
+  // Add all accessor Array functions to the wrapper.
+  each(['concat', 'join', 'slice'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
+    };
+  });
+
+  _.extend(_.prototype, {
+
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
+
+}).call(this);
+
+},{}]},{},[4]);
diff --git a/bower_components/fielddb-glosser/fielddb-glosser.min.js b/bower_components/fielddb-glosser/fielddb-glosser.min.js
new file mode 100644
index 0000000..73d4bfa
--- /dev/null
+++ b/bower_components/fielddb-glosser/fielddb-glosser.min.js
@@ -0,0 +1,19 @@
+/*! fielddb-glosser - v2.2.0 - 2017-03-12
+* https://github.com/OpenSourceFieldlinguistics/FieldDB/issues/milestones?state=closed
+* Copyright (c) 2017 FieldDB Contributors; Licensed Apache 2.0 */
+!function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error("Cannot find module '"+g+"'");throw j.code="MODULE_NOT_FOUND",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c?c:a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(a,b,c){"use strict";var d;try{d=document.Q||FieldDB.Q}catch(b){d||(d=a("q"))}var e={OFFLINE:{CODE:600,MESSAGE:"Unable to contact URL, you appear to be offline."},CLIENT_TIMEOUT:{CODE:500,MESSAGE:"The request to URL timed out, please try again. If this happens again, please report this."},CONNECTION_ABORTED:{CODE:500,MESSAGE:"The request to URL was aborted by the server, please report this."},CONNECTION_ERRORED:{CODE:500,MESSAGE:"Server is not responding for URL, please report this."},INTERNAL_SERVER_ERROR:{CODE:500},CLIENT_ERROR:{CODE:400},fieldDBtype:"CORS",timeout:3e4,debugMode:!1,debug:function(a,b,c){this.debugMode&&(a&&console.log("CORS-DEBUG: "+a),b&&console.log(b),c&&console.log(c))},warn:function(a,b,c){this.warnMessage&&this.warnMessage.indexOf("message")>-1||(this.warnMessage=this.warnMessage+a,console.warn("CORS-WARN: "+a),b&&console.log(b),c&&console.log(c))},bug:function(a){console.warn("CORS-BUG: "+a)},render:function(){this.debug("Render requested for CORS, but it doesnt know how to render itself.")},clearCookies:function(a){this.warn("TODO clear cookies requested for "+a)},preprocess:function(a){this.debug("\n\n\npreprocess "+a.url+" "+a.complete),a.complete=!1,a.percentComplete=0,a.method||(a.method=a.type||"GET"),a.url||this.bug("There was an error. Please report this."),a.data||(a.data=""),"GET"===a.method&&a.data&&(a.dataToSend=JSON.stringify(a.data).replace(/,/g,"&").replace(/:/g,"=").replace(/"/g,"").replace(/[}{]/g,""),a.url=a.url+"?"+a.dataToSend)},handleResponse:function(a,b){if(!a.complete){this.debug(a.url+" "+a.complete+":   handleResponse "+a.url);var c,d,e,f=a.xhr.responseJSON||a.xhr.responseText||a.xhr.response;try{f=JSON.parse(f)}catch(a){}if(f||(f={}),f.reason&&(f.message=f.reason,delete f.reason),(d=f.status||a.xhr.status)<400)return this.debug("done "+a.url+" "+a.complete+"\n\n\n"),a.complete=!0,a.percentComplete=100,void b.resolve(f);"object"!=typeof f&&(f={message:f}),c=new Error(f.userFriendlyErrors?f.userFriendlyErrors[0]:f.message);for(e in f)f.hasOwnProperty(e)&&(c[e]=f[e]);c.status=d,this.handleError(a,c,b)}},handleError:function(a,b,c){if(!a.complete){this.debug(a.url+" "+a.complete+":   handleError "+a.url);var d;if(this.debug(b.stack),d={userFriendlyErrors:b.userFriendlyErrors||[b.message||"There was an error contacting URL from "+window.location.href+" the app will not function normally. Please report this."],status:b.status||610,error:b},"missing"===d.userFriendlyErrors[0]?d.userFriendlyErrors.unshift("The server replied that "+a.url+" is missing, please report this."):"no_db_file"===d.userFriendlyErrors[0]&&d.userFriendlyErrors.unshift("That database doesn't exist. Are you sure this is the database you wanted to open: "+a.url),401===d.status&&e.application&&e.application.authentication&&e.application.authentication.dispatchEvent&&e.application.authentication.dispatchEvent("unauthorized"),d.status>=500)try{window&&window.navigator&&!window.navigator.onLine?(d.userFriendlyErrors.unshift(e.OFFLINE.MESSAGE),d.status=e.OFFLINE.CODE):b&&b.srcElement&&void 0!==b.srcElement.status&&(d.status=b.srcElement.status)}catch(a){}d.userFriendlyErrors[0]=d.userFriendlyErrors[0].replace("URL",a.url),this.bug(d.userFriendlyErrors[0]),d.details=a,d.details&&d.details.xhr&&(this.debug(a.url+" "+a.complete+":  cleaning up ",a.url),a.status=a.status||a.xhr.status,delete a.xhr),this.debug(a.url+" "+a.complete+": done "+a.url+"\n\n\n"),a.complete=!0,c.reject(d)}},setHeader:function(a,b,c){a.setRequestHeader(b,c)},ontimeout:function(a,b,c){var d=new Error(this.CLIENT_TIMEOUT.MESSAGE);this.debug(a.url+" "+a.complete+": timed out."),d.status=this.CLIENT_TIMEOUT.CODE,this.handleError(a,d,c)},onabort:function(a,b,c){var d=new Error(this.CONNECTION_ABORTED.MESSAGE);this.debug(a.url+" "+a.complete+": was aborted."),d.status=this.CONNECTION_ABORTED.CODE,this.handleError(a,d,c)},onerror:function(a,b,c){var d=new Error(this.CONNECTION_ERRORED.MESSAGE);this.debug(a.url+" "+a.complete+": errored."),a.xhr&&a.xhr.status?d.status=a.xhr.status:a.status?d.status=a.status:d.status=this.CONNECTION_ERRORED.CODE,this.handleError(a,d,c)},onload:function(a,b,c){this.handleResponse(a,c)},onprogress:function(a,b){if(this.debug(a.url+" "+a.complete+":  onprogress "+a.url+" "+a.complete,b),b.lengthComputable){var c=b.loaded/b.total*100;this.debug(a.url+" "+a.complete+":  percentComplete "+a.url,c),console.log("Percent complete "+a.url+" : "+c),a.complete||(a.percentComplete=c)}a.onprogress&&"function"==typeof a.onprogress&&a.onprogress(b)}};e.buildXhr=function(a){var b;try{b=new XMLHttpRequest}catch(a){return this.warn("XMLHttpRequest is not defined, nothing will happen.",a),null}if("withCredentials"in b)try{b.open(a.method,a.url,!0)}catch(a){return console.log(a),this.error=a.message,null}else"undefined"!=typeof XDomainRequest?(b=new XDomainRequest,b.open(a.method,a.url)):b=null;if(b)return this.setHeader(b,"Content-type","application/json"),a.withCredentials!==!1&&(b.withCredentials=!0,a.url.lastIndexOf(".")>a.url.lastIndexOf("/")&&0!==a.url.substring(a.url.lastIndexOf(".")).indexOf("htm")&&(b.withCredentials=!1)),(a.timeout||this.timeout)&&(b.timeout=a.timeout||this.timeout),b},e.makeCORSRequest=function(a){var b,c,e=this,f=d.defer();if(!a||!a.url)return d.nextTick(function(){f.reject({status:400,details:a,userFriendlyErrors:["Url must be defined"]})}),f.promise;if(this.preprocess(a,f),a.url=a.url.replace("corpusdev","corpus"),!(c=this.buildXhr(a))){var g=this.error||"CORS not supported, your device will be unable to contact "+a.url;return this.bug(g),d.nextTick(function(){f.reject({status:620,details:a,userFriendlyErrors:[g]})}),f.promise}if(a&&a.data&&a.data.files){console.log("converting to formdata ",a.data),b=new FormData;for(var h in a.data)a.data.hasOwnProperty(h)&&b.append(h,a.data[h]);b=b,this.setHeader(c,"Content-Type","multipart/form-data")}else a.data&&(b=JSON.stringify(a.data));c.onprogress=function(b){e.onprogress(a,b,f)},c.onload=function(b){e.onload(a,b,f)},c.onerror=function(b){e.onerror(a,b,f)},c.onabort=function(b){e.onabort(a,b,f)},c.ontimeout=function(b){e.ontimeout(a,b,f)},a.xhr=c;try{b?(e.debug(a.url+" "+a.complete+": sending ",b),c.send(b)):c.send()}catch(b){e.warn("Caught an exception when calling send on xhr",b),b.details=a,f.reject(b)}return f.promise};try{c.CORS=e}catch(a){}try{document}catch(b){var f=a("./CORSNode").CORS;console.warn("REST requests: enabled"),c.CORS=f||e}},{"./CORSNode":2,q:3}],2:[function(a,b,c){var d=a("q"),e=a("http"),f=a("https"),g=a("url"),h=a("./CORS").CORS;h.buildXhr=function(){},h.setHeader=function(a,b,c){a.setHeader(b,c)};var i={};h.clearCookies=function(a){a&&(this.warn("clearing cookies on "+a),delete i[a])},h.makeCORSRequest=function(a){var b,c=this,h=d.defer(),j="";if(!a||!a.url)return d.nextTick(function(){h.reject({status:400,details:a,userFriendlyErrors:["Url must be defined"]})}),h.promise;this.preprocess(a,h);var k=g.parse(a.url),l=e;"https:"===k.protocol&&(l=f,k.port=k.port||443),delete k.protocol,k.method=a.method||"GET",b=l.request(k,function(d){var e="";d.setEncoding("utf8"),c.debug(a.url+" "+a.complete+":  requesting "),d.on("data",function(b){e+=b,c.debug(a.url+" "+a.complete+":  ondata "),c.onprogress.apply(c,[a,{lengthComputable:!0,loaded:e.length-b.length,total:e.length},h])}),d.on("end",function(){b.responseText=e,b.status=d.statusCode,d.headers&&d.headers["set-cookie"]&&(i[k.host]=d.headers["set-cookie"],c.debug(a.url+" "+a.complete+": cookies",i)),c.debug(a.url+" "+a.complete+":  response headers "+a.url,d.headers),"DELETE"===a.method&&"/_session"===k.path&&c.clearCookies(k.host),c.onprogress.apply(c,[a,{lengthComputable:!0,loaded:e.length,total:e.length},h]),c.onload.apply(c,[a,{},h])})}),i[k.host]&&b.setHeader("Cookie",i[k.host].join(";")),c.debug(a.url+" "+a.complete+": request cookies "+b.getHeader("cookie")),b.setHeader("Content-type","application/json"),b.setTimeout(a.timeout||this.timeout),a&&a.data&&a.data.files||a.data&&(j=JSON.stringify(a.data)),b.on("error",function(b){c.onerror.apply(c,[a,b,h])}),b.on("timeout",function(d){c.ontimeout.apply(c,[a,d,h]),b.abort()}),a.xhr=b;try{j?(c.debug(a.url+" "+a.complete+": sending ",j),b.write(j)):b.write(""),b.end()}catch(b){c.warn("Caught an exception when calling send on xhr",b.stack),b.details=a,h.reject(b)}return h.promise},c&&(c.CORS=h)},{"./CORS":1,http:94,https:74,q:3,url:101}],3:[function(a,b,c){(function(a){!function(a){"use strict";if("function"==typeof bootstrap)bootstrap("promise",a);else if("object"==typeof c&&"object"==typeof b)b.exports=a();else if("function"==typeof define&&define.amd)define(a);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeQ=a}else{if("undefined"==typeof window&&"undefined"==typeof self)throw new Error("This environment was not anticipated by Q. Please file a bug.");var d="undefined"!=typeof window?window:self,e=d.Q;d.Q=a(),d.Q.noConflict=function(){return d.Q=e,this}}}(function(){"use strict";function b(a){return function(){return V.apply(a,arguments)}}function c(a){return a===Object(a)}function d(a){return"[object StopIteration]"===ba(a)||a instanceof R}function e(a,b){if(P&&b.stack&&"object"==typeof a&&null!==a&&a.stack&&a.stack.indexOf(ca)===-1){for(var c=[],d=b;d;d=d.source)d.stack&&c.unshift(d.stack);c.unshift(a.stack);var e=c.join("\n"+ca+"\n");a.stack=f(e)}}function f(a){for(var b=a.split("\n"),c=[],d=0;d<b.length;++d){var e=b[d];i(e)||g(e)||!e||c.push(e)}return c.join("\n")}function g(a){return a.indexOf("(module.js:")!==-1||a.indexOf("(node.js:")!==-1}function h(a){var b=/at .+ \((.+):(\d+):(?:\d+)\)$/.exec(a);if(b)return[b[1],Number(b[2])];var c=/at ([^ ]+):(\d+):(?:\d+)$/.exec(a);if(c)return[c[1],Number(c[2])];var d=/.*@(.+):(\d+)$/.exec(a);return d?[d[1],Number(d[2])]:void 0}function i(a){var b=h(a);if(!b)return!1;var c=b[0],d=b[1];return c===Q&&d>=S&&d<=ha}function j(){if(P)try{throw new Error}catch(d){var a=d.stack.split("\n"),b=a[0].indexOf("@")>0?a[1]:a[2],c=h(b);if(!c)return;return Q=c[0],c[1]}}function k(a){return a instanceof o?a:s(a)?B(a):A(a)}function l(){function a(a){b=a,f.source=a,X(c,function(b,c){k.nextTick(function(){a.promiseDispatch.apply(a,c)})},void 0),c=void 0,d=void 0}var b,c=[],d=[],e=$(l.prototype),f=$(o.prototype);if(f.promiseDispatch=function(a,e,f){var g=W(arguments);c?(c.push(g),"when"===e&&f[1]&&d.push(f[1])):k.nextTick(function(){b.promiseDispatch.apply(b,g)})},f.valueOf=function(){if(c)return f;var a=q(b);return r(a)&&(b=a),a},f.inspect=function(){return b?b.inspect():{state:"pending"}},k.longStackSupport&&P)try{throw new Error}catch(a){f.stack=a.stack.substring(a.stack.indexOf("\n")+1)}return e.promise=f,e.resolve=function(c){b||a(k(c))},e.fulfill=function(c){b||a(A(c))},e.reject=function(c){b||a(z(c))},e.notify=function(a){b||X(d,function(b,c){k.nextTick(function(){c(a)})},void 0)},e}function m(a){if("function"!=typeof a)throw new TypeError("resolver must be a function.");var b=l();try{a(b.resolve,b.reject,b.notify)}catch(a){b.reject(a)}return b.promise}function n(a){return m(function(b,c){for(var d=0,e=a.length;d<e;d++)k(a[d]).then(b,c)})}function o(a,b,c){void 0===b&&(b=function(a){return z(new Error("Promise does not support operation: "+a))}),void 0===c&&(c=function(){return{state:"unknown"}});var d=$(o.prototype);if(d.promiseDispatch=function(c,e,f){var g;try{g=a[e]?a[e].apply(d,f):b.call(d,e,f)}catch(a){g=z(a)}c&&c(g)},d.inspect=c,c){var e=c();"rejected"===e.state&&(d.exception=e.reason),d.valueOf=function(){var a=c();return"pending"===a.state||"rejected"===a.state?d:a.value}}return d}function p(a,b,c,d){return k(a).then(b,c,d)}function q(a){if(r(a)){var b=a.inspect();if("fulfilled"===b.state)return b.value}return a}function r(a){return a instanceof o}function s(a){return c(a)&&"function"==typeof a.then}function t(a){return r(a)&&"pending"===a.inspect().state}function u(a){return!r(a)||"fulfilled"===a.inspect().state}function v(a){return r(a)&&"rejected"===a.inspect().state}function w(){da.length=0,ea.length=0,ga||(ga=!0)}function x(b,c){ga&&("object"==typeof a&&"function"==typeof a.emit&&k.nextTick.runAfter(function(){Y(ea,b)!==-1&&(a.emit("unhandledRejection",c,b),fa.push(b))}),ea.push(b),c&&void 0!==c.stack?da.push(c.stack):da.push("(no stack) "+c))}function y(b){if(ga){var c=Y(ea,b);c!==-1&&("object"==typeof a&&"function"==typeof a.emit&&k.nextTick.runAfter(function(){var d=Y(fa,b);d!==-1&&(a.emit("rejectionHandled",da[c],b),fa.splice(d,1))}),ea.splice(c,1),da.splice(c,1))}}function z(a){var b=o({when:function(b){return b&&y(this),b?b(a):this}},function(){return this},function(){return{state:"rejected",reason:a}});return x(b,a),b}function A(a){return o({when:function(){return a},get:function(b){return a[b]},set:function(b,c){a[b]=c},delete:function(b){delete a[b]},post:function(b,c){return null===b||void 0===b?a.apply(void 0,c):a[b].apply(a,c)},apply:function(b,c){return a.apply(b,c)},keys:function(){return aa(a)}},void 0,function(){return{state:"fulfilled",value:a}})}function B(a){var b=l();return k.nextTick(function(){try{a.then(b.resolve,b.reject,b.notify)}catch(a){b.reject(a)}}),b.promise}function C(a){return o({isDef:function(){}},function(b,c){return I(a,b,c)},function(){return k(a).inspect()})}function D(a,b,c){return k(a).spread(b,c)}function E(a){return function(){function b(a,b){var g;if("undefined"==typeof StopIteration){try{g=c[a](b)}catch(a){return z(a)}return g.done?k(g.value):p(g.value,e,f)}try{g=c[a](b)}catch(a){return d(a)?k(a.value):z(a)}return p(g,e,f)}var c=a.apply(this,arguments),e=b.bind(b,"next"),f=b.bind(b,"throw");return e()}}function F(a){k.done(k.async(a)())}function G(a){throw new R(a)}function H(a){return function(){return D([this,J(arguments)],function(b,c){return a.apply(b,c)})}}function I(a,b,c){return k(a).dispatch(b,c)}function J(a){return p(a,function(a){var b=0,c=l();return X(a,function(d,e,f){var g;r(e)&&"fulfilled"===(g=e.inspect()).state?a[f]=g.value:(++b,p(e,function(d){a[f]=d,0==--b&&c.resolve(a)},c.reject,function(a){c.notify({index:f,value:a})}))},void 0),0===b&&c.resolve(a),c.promise})}function K(a){if(0===a.length)return k.resolve();var b=k.defer(),c=0;return X(a,function(d,e,f){function g(a){b.resolve(a)}function h(){0===--c&&b.reject(new Error("Can't get fulfillment value from any promise, all promises were rejected."))}function i(a){b.notify({index:f,value:a})}var j=a[f];c++,p(j,g,h,i)},void 0),b.promise}function L(a){return p(a,function(a){return a=Z(a,k),p(J(Z(a,function(a){return p(a,T,T)})),function(){return a})})}function M(a){return k(a).allSettled()}function N(a,b){return k(a).then(void 0,void 0,b)}function O(a,b){return k(a).nodeify(b)}var P=!1;try{throw new Error}catch(a){P=!!a.stack}var Q,R,S=j(),T=function(){},U=function(){function b(){for(var a,b;d.next;)d=d.next,a=d.task,d.task=void 0,b=d.domain,b&&(d.domain=void 0,b.enter()),c(a,b);for(;i.length;)a=i.pop(),c(a);f=!1}function c(a,c){try{a()}catch(a){if(h)throw c&&c.exit(),setTimeout(b,0),c&&c.enter(),a;setTimeout(function(){throw a},0)}c&&c.exit()}var d={task:void 0,next:null},e=d,f=!1,g=void 0,h=!1,i=[];if(U=function(b){e=e.next={task:b,domain:h&&a.domain,next:null},f||(f=!0,g())},"object"==typeof a&&"[object process]"===a.toString()&&a.nextTick)h=!0,g=function(){a.nextTick(b)};else if("function"==typeof setImmediate)g="undefined"!=typeof window?setImmediate.bind(window,b):function(){setImmediate(b)};else if("undefined"!=typeof MessageChannel){var j=new MessageChannel;j.port1.onmessage=function(){g=k,j.port1.onmessage=b,b()};var k=function(){j.port2.postMessage(0)};g=function(){setTimeout(b,0),k()}}else g=function(){setTimeout(b,0)};return U.runAfter=function(a){i.push(a),f||(f=!0,g())},U}(),V=Function.call,W=b(Array.prototype.slice),X=b(Array.prototype.reduce||function(a,b){var c=0,d=this.length;if(1===arguments.length)for(;;){if(c in this){b=this[c++];break}if(++c>=d)throw new TypeError}for(;c<d;c++)c in this&&(b=a(b,this[c],c));return b}),Y=b(Array.prototype.indexOf||function(a){for(var b=0;b<this.length;b++)if(this[b]===a)return b;return-1}),Z=b(Array.prototype.map||function(a,b){var c=this,d=[];return X(c,function(e,f,g){d.push(a.call(b,f,g,c))},void 0),d}),$=Object.create||function(a){function b(){}return b.prototype=a,new b},_=b(Object.prototype.hasOwnProperty),aa=Object.keys||function(a){var b=[];for(var c in a)_(a,c)&&b.push(c);return b},ba=b(Object.prototype.toString);R="undefined"!=typeof ReturnValue?ReturnValue:function(a){this.value=a};var ca="From previous event:";k.resolve=k,k.nextTick=U,k.longStackSupport=!1,"object"==typeof a&&a&&a.env&&a.env.Q_DEBUG&&(k.longStackSupport=!0),k.defer=l,l.prototype.makeNodeResolver=function(){var a=this;return function(b,c){b?a.reject(b):arguments.length>2?a.resolve(W(arguments,1)):a.resolve(c)}},k.Promise=m,k.promise=m,m.race=n,m.all=J,m.reject=z,m.resolve=k,k.passByCopy=function(a){return a},o.prototype.passByCopy=function(){return this},k.join=function(a,b){return k(a).join(b)},o.prototype.join=function(a){return k([this,a]).spread(function(a,b){if(a===b)return a;throw new Error("Can't join: not the same: "+a+" "+b)})},k.race=n,o.prototype.race=function(){return this.then(k.race)},k.makePromise=o,o.prototype.toString=function(){return"[object Promise]"},o.prototype.then=function(a,b,c){function d(b){try{return"function"==typeof a?a(b):b}catch(a){return z(a)}}function f(a){if("function"==typeof b){e(a,h);try{return b(a)}catch(a){return z(a)}}return z(a)}function g(a){return"function"==typeof c?c(a):a}var h=this,i=l(),j=!1;return k.nextTick(function(){h.promiseDispatch(function(a){j||(j=!0,i.resolve(d(a)))},"when",[function(a){j||(j=!0,i.resolve(f(a)))}])}),h.promiseDispatch(void 0,"when",[void 0,function(a){var b,c=!1;try{b=g(a)}catch(a){if(c=!0,!k.onerror)throw a;k.onerror(a)}c||i.notify(b)}]),i.promise},k.tap=function(a,b){return k(a).tap(b)},o.prototype.tap=function(a){return a=k(a),this.then(function(b){return a.fcall(b).thenResolve(b)})},k.when=p,o.prototype.thenResolve=function(a){return this.then(function(){return a})},k.thenResolve=function(a,b){return k(a).thenResolve(b)},o.prototype.thenReject=function(a){return this.then(function(){throw a})},k.thenReject=function(a,b){return k(a).thenReject(b)},k.nearer=q,k.isPromise=r,k.isPromiseAlike=s,k.isPending=t,o.prototype.isPending=function(){return"pending"===this.inspect().state},k.isFulfilled=u,o.prototype.isFulfilled=function(){return"fulfilled"===this.inspect().state},k.isRejected=v,o.prototype.isRejected=function(){return"rejected"===this.inspect().state};var da=[],ea=[],fa=[],ga=!0;k.resetUnhandledRejections=w,k.getUnhandledReasons=function(){return da.slice()},k.stopUnhandledRejectionTracking=function(){w(),ga=!1},w(),k.reject=z,k.fulfill=A,k.master=C,k.spread=D,o.prototype.spread=function(a,b){return this.all().then(function(b){return a.apply(void 0,b)},b)},k.async=E,k.spawn=F,k.return=G,k.promised=H,k.dispatch=I,o.prototype.dispatch=function(a,b){var c=this,d=l();return k.nextTick(function(){c.promiseDispatch(d.resolve,a,b)}),d.promise},k.get=function(a,b){return k(a).dispatch("get",[b])},o.prototype.get=function(a){return this.dispatch("get",[a])},k.set=function(a,b,c){return k(a).dispatch("set",[b,c])},o.prototype.set=function(a,b){return this.dispatch("set",[a,b])},k.del=k.delete=function(a,b){return k(a).dispatch("delete",[b])},o.prototype.del=o.prototype.delete=function(a){return this.dispatch("delete",[a])},k.mapply=k.post=function(a,b,c){return k(a).dispatch("post",[b,c])},o.prototype.mapply=o.prototype.post=function(a,b){return this.dispatch("post",[a,b])},k.send=k.mcall=k.invoke=function(a,b){return k(a).dispatch("post",[b,W(arguments,2)])},o.prototype.send=o.prototype.mcall=o.prototype.invoke=function(a){return this.dispatch("post",[a,W(arguments,1)])},k.fapply=function(a,b){return k(a).dispatch("apply",[void 0,b])},o.prototype.fapply=function(a){return this.dispatch("apply",[void 0,a])},k.try=k.fcall=function(a){return k(a).dispatch("apply",[void 0,W(arguments,1)])},o.prototype.fcall=function(){return this.dispatch("apply",[void 0,W(arguments)])},k.fbind=function(a){var b=k(a),c=W(arguments,1);return function(){return b.dispatch("apply",[this,c.concat(W(arguments))])}},o.prototype.fbind=function(){var a=this,b=W(arguments);return function(){return a.dispatch("apply",[this,b.concat(W(arguments))])}},k.keys=function(a){return k(a).dispatch("keys",[])},o.prototype.keys=function(){return this.dispatch("keys",[])},k.all=J,o.prototype.all=function(){return J(this)},k.any=K,o.prototype.any=function(){return K(this)},k.allResolved=function(a,b,c){return function(){return"undefined"!=typeof console&&"function"==typeof console.warn&&console.warn(b+" is deprecated, use "+c+" instead.",new Error("").stack),a.apply(a,arguments)}}(L,"allResolved","allSettled"),o.prototype.allResolved=function(){return L(this)},k.allSettled=M,o.prototype.allSettled=function(){return this.then(function(a){return J(Z(a,function(a){function b(){return a.inspect()}return a=k(a),a.then(b,b)}))})},k.fail=k.catch=function(a,b){return k(a).then(void 0,b)},o.prototype.fail=o.prototype.catch=function(a){return this.then(void 0,a)},k.progress=N,o.prototype.progress=function(a){return this.then(void 0,void 0,a)},k.fin=k.finally=function(a,b){return k(a).finally(b)},o.prototype.fin=o.prototype.finally=function(a){return a=k(a),this.then(function(b){return a.fcall().then(function(){return b})},function(b){return a.fcall().then(function(){throw b})})},k.done=function(a,b,c,d){return k(a).done(b,c,d)},o.prototype.done=function(b,c,d){var f=function(a){k.nextTick(function(){if(e(a,g),!k.onerror)throw a;k.onerror(a)})},g=b||c||d?this.then(b,c,d):this;"object"==typeof a&&a&&a.domain&&(f=a.domain.bind(f)),g.then(void 0,f)},k.timeout=function(a,b,c){return k(a).timeout(b,c)},o.prototype.timeout=function(a,b){var c=l(),d=setTimeout(function(){b&&"string"!=typeof b||(b=new Error(b||"Timed out after "+a+" ms"),b.code="ETIMEDOUT"),c.reject(b)},a);return this.then(function(a){clearTimeout(d),c.resolve(a)},function(a){clearTimeout(d),c.reject(a)},c.notify),c.promise},k.delay=function(a,b){return void 0===b&&(b=a,a=void 0),k(a).delay(b)},o.prototype.delay=function(a){return this.then(function(b){var c=l();return setTimeout(function(){c.resolve(b)},a),c.promise})},k.nfapply=function(a,b){return k(a).nfapply(b)},o.prototype.nfapply=function(a){var b=l(),c=W(a);return c.push(b.makeNodeResolver()),this.fapply(c).fail(b.reject),b.promise},k.nfcall=function(a){var b=W(arguments,1);return k(a).nfapply(b)},o.prototype.nfcall=function(){var a=W(arguments),b=l();return a.push(b.makeNodeResolver()),this.fapply(a).fail(b.reject),b.promise},k.nfbind=k.denodeify=function(a){var b=W(arguments,1);return function(){var c=b.concat(W(arguments)),d=l();return c.push(d.makeNodeResolver()),k(a).fapply(c).fail(d.reject),d.promise}},o.prototype.nfbind=o.prototype.denodeify=function(){var a=W(arguments);return a.unshift(this),k.denodeify.apply(void 0,a)},k.nbind=function(a,b){var c=W(arguments,2);return function(){function d(){return a.apply(b,arguments)}var e=c.concat(W(arguments)),f=l();return e.push(f.makeNodeResolver()),k(d).fapply(e).fail(f.reject),f.promise}},o.prototype.nbind=function(){var a=W(arguments,0);return a.unshift(this),k.nbind.apply(void 0,a)},k.nmapply=k.npost=function(a,b,c){return k(a).npost(b,c)},o.prototype.nmapply=o.prototype.npost=function(a,b){var c=W(b||[]),d=l();return c.push(d.makeNodeResolver()),this.dispatch("post",[a,c]).fail(d.reject),d.promise},k.nsend=k.nmcall=k.ninvoke=function(a,b){var c=W(arguments,2),d=l();return c.push(d.makeNodeResolver()),k(a).dispatch("post",[b,c]).fail(d.reject),d.promise},o.prototype.nsend=o.prototype.nmcall=o.prototype.ninvoke=function(a){var b=W(arguments,1),c=l();return b.push(c.makeNodeResolver()),this.dispatch("post",[a,b]).fail(c.reject),c.promise},k.nodeify=O,o.prototype.nodeify=function(a){if(!a)return this;this.then(function(b){k.nextTick(function(){a(null,b)})},function(b){k.nextTick(function(){a(b)})})},k.noConflict=function(){throw new Error("Q.noConflict only works when Q is used as a global")};var ha=j();return k})}).call(this,a("_process"))},{_process:77}],4:[function(a,b,c){(function(b){var d=d||a("d3"),e=e||a("underscore");a("./Lexicon").LexiconFactory;!function(a){"use strict";var c=function(a){var b;b=a&&a.XMLHttpRequestLocal?a.XMLHttpRequestLocal:window.XMLHttpRequest;for(var c in a)a.hasOwnProperty(c)&&(this[c]=a[c]);var f=f||{debugMode:!0,bug:function(a){console.log(a)},debug:function(a,b,c,d){this.debugMode&&(console.log(a),b&&console.log(b),c&&console.log(c),d&&console.log(d))},makeCORSRequest:function(a){f.debugMode=!1,a.method||(a.method=a.type||"GET"),a.url||f.bug("There was an error. Please report this."),a.data||(a.data=""),a.dataToSend=JSON.stringify(a.data).replace(/,/g,"&").replace(/:/g,"=").replace(/"/g,"").replace(/[}{]/g,""),"GET"===a.method&&a.data&&(a.url=a.url+"?"+a.dataToSend);var c=function(a,c){var d=new b;return"withCredentials"in d?d.open(a,c,!0):"undefined"!=typeof XDomainRequest?(d=new XDomainRequest,d.open(a,c)):d=null,d}(a.method,a.url);if(!c)return void f.bug("CORS not supported, your browser is unable to contact the database.");c.setRequestHeader("Content-type","application/json"),c.withCredentials=!0,c.onload=function(b,d,e){var g=c.responseText;f.debugMode&&f.debug("Response from CORS request to "+a.url+": "+g),"function"==typeof a.success&&(g?a.success(JSON.parse(g)):(f.bug("There was no content in the server's response text. Please report this."),a.error(b,d,e))),f.debugMode=!1},c.onerror=function(b,c,d){f.debugMode&&f.debug(b,c,d),f.bug("There was an error making the CORS request to "+a.url+" from "+window.location.href+" the app will not function normally. Please report this."),"function"==typeof a.error&&a.error(b,c,d)},"POST"===a.method?c.send(JSON.stringify(a.data)):c.send()}};return this.currentCorpusName="",this.downloadPrecedenceRules=function(a,b,c){if(!b||"default"===b){if(!window.app)throw"Glosser cant be guessed, there is no app so the URL must be defined.";var d=window.app.get("corpus").get("couchConnection");b=f.getCouchUrl(d)+"/_design/pages/_view/precedence_rules?group=true"}var g=this;f.makeCORSRequest({type:"GET",url:b,success:function(b){var d=e.chain(b.rows).groupBy(function(a){return 1===a.key.distance&&(a.key.previous&&a.key.previous.morphemes&&(a.key.x=a.key.previous.morphemes),a.key.subsequent&&a.key.subsequent.morphemes&&(a.key.y=a.key.subsequent.morphemes)),a.key.x+"-"+a.key.y}).value();try{localStorage.setItem(a+"reducedRules",JSON.stringify(d))}catch(b){for(var f in localStorage)f.indexOf("reducedRules")>-1&&localStorage.removeItem(f);try{localStorage.setItem(a+"reducedRules",JSON.stringify(d))}catch(a){console.warn("Your lexicon is huge!",a)}}g.reducedRules=d,g.currentCorpusName=a,"function"==typeof c&&c(b.rows)},error:function(a){console.log("error getting precedence rules:",a)},dataType:""})},this.morphemefinder=function(a,b,c){if(!a)return"";if(c)return a;if(!b){if(!window.app||!window.app.get("corpus"))throw"Glosser can't be guessed, there is no app so the URL must be defined.";b=window.app.get("corpus").get("couchConnection").pouchname}var d="",e=this.reducedRules||localStorage.getItem(b+"reducedRules"),g=[];if(e){e=JSON.parse(e);var h=a.trim().split(/ +/);for(var i in h){h[i]="@"+h[i]+"@";var j=[];for(var k in e)h[i].indexOf(k.replace(/-/,""))>=0&&j.push({r:e[k]});var l=[];l.push("@");for(var m=0;m<10&&void 0!==l[m];m++)for(var n in j)if(!(l.length>2&&"@"===l[l.length-1])&&l[m]===j[n].r[0].key.x){if(l[m+1]){l.pop();break}l[m+1]=j[n].r[0].key.y}if(l.length>2&&"@"===l[0]&&"@"===l[l.length-1])l.pop(),l.shift(),g.push(l.join("-"));else{var o=[];if("@"!==l[l.length-1]||1===l.length){o.push("@");for(var p=0;p<10&&void 0!==o[p];p++)for(var q in j)if(o[p]===j[q].r[0].key.y){if(o[p+1]){o.pop();break}o[p+1]=j[q].r[0].key.x}}var r=[];r=l.concat(o.reverse());for(var s in r)r[s]="("+r[s]+")";var t=new RegExp(r.join("(.*)"),"");d=h[i].replace(t,"$1-$2-$3-$4-$5-$6-$7-$8-$9").replace(/\$[0-9]/g,"").replace(/@/g,"").replace(/--+/g,"-").replace(/^-/,"").replace(/-$/,""),f.debugMode&&f.debug("Potential parse of "+h[i].replace(/@/g,"")+" is "+d),g.push(d)}}}return g.join(" ")},this.contextSensitiveGlossFinder=function(a,b,c){var d=a.morphemes;if(!d)return"";if(c||!this.lexicon){var e=d.trim().replace(/[^ =-]+/g,"?");a.gloss=e}else a=this.lexicon.guessContextSensitiveGlosses(a);return a},this.simplisticGlossFinder=function(a,b,c){if(!a)return"";if(c){return a.trim().replace(/[^ -]+/g,"?")}if(!b){if(!window.app||!window.app.get("corpus"))throw"Glosser can't be guessed, there is no app so the URL must be defined.";b=window.app.get("corpus").get("couchConnection").pouchname}var d=localStorage.getItem(b+"lexiconResults");if(!d)return"";d=JSON.parse(d);var e=[],g=a.split(/ +/);for(var h in g){var i=g[h].split("-"),j=[];for(var k in i){var l=[],m=d[i[k]];m&&l.push(m),m=d[i[k].toLowerCase()],m&&l.push(m);var n="?";if(l.length>0){console.log("Glosses which match: ",l);try{n=l[0][0].gloss}catch(a){f.debug(l)}}j.push(n)}e.push(j.join("-"))}return e.join(" ")},this.guessUtteranceFromMorphemes=function(a,b){return!a.utterance&&a.morphemes&&(a.utterance=a.morphemes.replace(/[-.]/g,"")),a},this.guessMorphemesFromUtterance=function(a,b){return a.morphemes?a:(a.morphemes=this.morphemefinder(a.utterance,a.pouchname,b),a.gloss||(a=this.contextSensitiveGlossFinder(a,a.pouchname,b)),a)},this.guessGlossFromMorphemes=function(a,b){return a.gloss?a:(a.morphemes||(a.morphemes=a.utterance),a=this.contextSensitiveGlossFinder(a,a.pouchname,b))},this.generateForceDirectedRulesJsonForD3=function(a,b){if(b||(b=this.currentCorpusName),a||(a=this.reducedRules)||(localStorage.getItem(b+"precendenceRules"),a&&(a=JSON.parse(a))),a){var c=[],d=[];for(var e in a){"@"===a[e].key.x&&(a[e].key.x="#_"),"@"===a[e].key.y&&(a[e].key.y="_#");var f=d.indexOf(a[e].key.x);f<0&&(d.push(a[e].key.x),f=d.length-1);var g=d.indexOf(a[e].key.y);g<0&&(d.push(a[e].key.y),g=d.length-1),a[e].key.y.indexOf("@")===-1&&c.push({source:f,target:g,value:1})}var h=[];for(var i in d)h.push({name:d[i],length:d[i].length});var j={};return j.links=c,j.nodes=h,this.rulesGraph=j,j}},this.saveAndInterConnectInApp=function(a){"function"==typeof a&&a()},this.visualizeMorphemesAsForceDirectedGraph=function(a,b,c){if(!c)throw"Must provide corpus name to be able to visualize morphemes";if(this.currentCorpusName=c,a||(a=this.rulesGraph,a?0===a.links.length&&(a=this.generateForceDirectedRulesJsonForD3()):a=this.generateForceDirectedRulesJsonForD3()),a&&0!==this.rulesGraph.links.length){var e=a,f=d.scale.linear().range(["darkblue","darkred"]).domain([1,8]),g=d.scale.linear().range(["#FFFFF","#FFFF00"]).domain([1,8]),h=(d.scale.linear().range([0,800]),d.scale.linear().range([0,260]),d.layout.force().charge(-120).linkDistance(30).size([800,300])),i=d.select(b).append("svg").attr("width",800).attr("title","Morphology Visualization for "+c).attr("height",300),j="Click to search morphemes in your corpus";a.nodes.length<3&&(j="Your morpheme visualizer will appear here after you have synced.");var k=(i.append("text").attr("class","vis-title").attr("dy","1em").attr("dx","1em").style("fill","#cccccc").text(j),null);h.nodes(e.nodes).links(e.links).start();var l=i.selectAll("line.link").data(e.links).enter().append("line").attr("class","link").style("stroke",function(a){return g(a.value)}).style("stroke-width",function(a){return a.value}),m=i.selectAll("circle.node").data(e.nodes).enter().append("circle").attr("class","node").attr("r",5).attr("data-details",function(a){return a}).style("fill",function(a){
+return"#_"===a.igt.morphemes?"#00000":"_#"===a.igt.morphemes?"#ffffff":f(a.length)}).on("mouseover",function(a){k=d.select("body").append("div").style("position","absolute").style("z-index","10").style("visibility","visible").style("color","#fff").text(a.igt.morphemes)}).on("mouseout",function(){k.style("visibility","hidden")}).on("click",function(a){if(window.app&&window.app.router){var b="corpus/"+c+"/search/morphemes:"+a.igt.morphemes;window.app.router.navigate(b,{trigger:!0})}}).call(h.drag);m.append("title").text(function(a){return a.igt.morphemes}),h.on("tick",function(){l.attr("x1",function(a){return a.source.x}).attr("y1",function(a){return a.source.y}).attr("x2",function(a){return a.target.x}).attr("y2",function(a){return a.target.y}),m.attr("cx",function(a){return a.x}).attr("cy",function(a){return a.y})})}},this.visualizePrecedenceRelationsAsForceDirectedGraph=function(a,b,c,e){var f={links:[],nodes:{}};if(!this.localDocument)return void console.warn(" Glosser Visualization requested but the DOM was not provided to the glosser ");var g=this.localDocument;if(a.precedenceGraph=a.precedenceRelations.filter(function(a){a.key.previous&&a.key.subsequent&&a.key.previous.morphemes&&a.key.subsequent.morphemes&&("@"!==a.key.previous.morphemes&&"_#"!==a.key.previous.morphemes&&"#_"!==a.key.previous.morphemes&&"@"!==a.key.subsequent.morphemes&&"_#"!==a.key.subsequent.morphemes&&"#_"!==a.key.subsequent.morphemes||!c)&&("@"===a.key.previous.morphemes&&(a.key.previous.morphemes="#_"),"@"===a.key.subsequent.morphemes&&(a.key.subsequent.morphemes="_#"),a.key.distance>1||"precedes"===a.key.relation&&(e=e||1,a.key.previous.confidence<e||a.key.subsequent.confidence<e||(a.key.source=a.key.previous,a.key.target=a.key.subsequent,f.links.push(a.key))))}),a.precedenceGraph=f,a.precedenceGraph&&0!==a.precedenceGraph.links.length){var h=b.clientWidth;a.precedenceGraph.links.map(function(b){b&&b.source&&b.source.morphemes&&b.target&&b.target.morphemes&&(a.precedenceGraph.nodes[b.source.morphemes]||(a.precedenceGraph.nodes[b.source.morphemes]={igt:b.source}),b.source=a.precedenceGraph.nodes[b.source.morphemes],a.precedenceGraph.nodes[b.target.morphemes]||(a.precedenceGraph.nodes[b.target.morphemes]={igt:b.target}),b.target=a.precedenceGraph.nodes[b.target.morphemes])}),window.mylexicon=a;var i=d.select("body").append("div").style("position","absolute").style("z-index","10").style("visibility","hidden").html(""),j=function(a){var b=a.source.x-a.target.x,c=a.source.y-a.target.y,d=Math.sqrt(b*b+c*c);return"M"+a.source.x+","+a.source.y+"A"+d+","+d+" 0 0,1 "+a.target.x+","+a.target.y},k=function(a){return"_#"===a.igt.morphemes&&(a.x=h-20,a.y=300),"#_"===a.igt.morphemes&&(a.x=20,a.y=300),"translate("+a.x+","+a.y+")"},l=d.scale.linear().range(["darkblue","darkred"]).domain([1,8]),m=(d.scale.linear().range(["#FFFFF","#FFFF00"]).domain([1,8]),d.layout.force().nodes(d.values(a.precedenceGraph.nodes)).links(a.precedenceGraph.links).size([h,600]).linkStrength(.5).linkDistance(60).charge(-400)),n=d.select(b).append("svg").attr("width",h).attr("height",600);n.append("defs").selectAll("marker").data(["precedes"]).enter().append("marker").attr("id",function(a){return a}).style("opacity",function(a){return.5}).attr("viewBox","0 -5 10 10").attr("refX",15).attr("refY",-1.5).attr("markerWidth",6).attr("markerHeight",6).attr("orient","auto").append("path").attr("d","M0,-5L10,0L0,5");var o=n.append("g").selectAll("path").data(m.links()).enter().append("path").attr("class",function(a){return"link "+a.relation+" distance"+a.distance}).attr("marker-end",function(a){return"url(#"+a.relation+")"}),p=n.append("g").selectAll("circle").data(m.nodes()).enter().append("circle").attr("class","node").attr("r",5).style("fill",function(a){return"#_"===a.igt.morphemes?"#00000":"_#"===a.igt.morphemes?"#ffffff":l(a.igt.morphemes.length)}).style("opacity",function(a){return a.igt.confidence?a.igt.confidence/2:1}).on("mouseover",function(a){var b=g.getElementById(a.igt.morphemes);return b=b?b.innerHTML+"<p>"+b.getAttribute("title")+"<p>":"Morpheme: "+a.igt.morphemes+"<br/> Gloss: "+a.igt.gloss+"<br/> Confidence: "+a.igt.confidence,i.style("visibility","visible").html("<div class='node_details_tooltip lexicon'>"+b+"</div>")}).on("mousemove",function(a){return i.style("top",event.pageY-10+"px").style("left",event.pageX+10+"px")}).on("mouseout",function(a){return i.style("visibility","hidden")}).on("click",function(b){if(window.app&&window.app.router){var c="corpus/"+a.pouchname+"/search/morphemes:"+b.igt.morphemes;window.app.router.navigate(c,{trigger:!0})}}).call(m.drag),q=n.append("g").selectAll("text").data(m.nodes()).enter().append("text").attr("x",8).attr("y",".31em").style("opacity",function(a){return a.igt.confidence?a.igt.confidence/2:1}).style("color",function(a){return"#_"===a.igt.morphemes?"#00000":"_#"===a.igt.morphemes?"#ffffff":l(a.igt.morphemes.length)}).text(function(a){return a.igt.morphemes}),r=function(){o.attr("d",j),p.attr("transform",k),q.attr("transform",k)};m.on("tick",r).start()}},this};a.Glosser=c,b.Glosser=c}("object"==typeof c&&c||this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./Lexicon":5,d3:25,underscore:105}],5:[function(a,b,c){(function(b){var d=(a("frb/dom"),a("frb/bindings")),e=a("collections/sorted-set"),f=a("collections/set"),g=a("../../FieldDB/api/CORS").CORS,h=a("q");!function(a){var c=function(a){return a.replace(/([()[{*+.$^\\|?])/g,"\\$1")},i=function(a){for(var b in a)a.hasOwnProperty(b)&&(this[b]=a[b]);this.fossil=JSON.parse(JSON.stringify(a.igt)),Object.call(this)};i.prototype=Object.create(Object.prototype,{constructor:{value:i},equals:{value:function(a){var b,c,d,e=this,f=!1;for(b in this.expandedIGTFields)c=this.expandedIGTFields[b],e.igt.hasOwnProperty(c)&&e.igt[c]===a.igt[c]&&(f=!0);if(f){for(b in this.combineFieldsIfEqual)c=this.combineFieldsIfEqual[b],e.hasOwnProperty(c)&&(d=[],e[c]=e[c].concat(a[c]),e[c].map(function(a){d.indexOf(a)===-1&&d.push(a)}),e[c]=d,a[c]=d);if(e.confidence&&a.confidence&&(e.confidence=(parseFloat(e.confidence,10)+parseFloat(a.confidence,10))/2,a.confidence=e.confidence),e.allomorphs||a.allomorphs){var g=e.allomorphs?e.allomorphs:"";g=g+g?", ":"",g=g+a.allomorphs?a.allomorphs:"",e.allomorphs=g,a.allomorphs=g}}return f}},expandedIGTFields:{value:["morphemes","gloss","allomorphy","phonetic","orthography"]},combineFieldsIfEqual:{value:["datumids","utteranceContext"]},sortBy:{value:"morphemes",writable:!0},compare:{value:function(a){var b=this;return a&&a.igt&&a.igt[this.sortBy]?b&&b.igt&&b.igt[this.sortBy]?"number"==typeof b.igt[this.sortBy]&&"number"==typeof a.igt[this.sortBy]?b.igt[this.sortBy]-a.igt[this.sortBy]:"string"==typeof b.igt[this.sortBy]&&"string"==typeof a.igt[this.sortBy]?b.igt[this.sortBy]<a.igt[this.sortBy]?-1:b.igt[this.sortBy]>a.igt[this.sortBy]?1:0:"string"==typeof b.igt[this.sortBy]?1:-1:1:-1}},clean:{value:function(){console.log("Preparing datum with this lexical entry to be cleaned...");var a=h.defer();this.cleanedData=[];var b=[],d=this;this.proposedChanges=[];for(var e=function(a){console.log(a),a.datumFields.map(function(a){if(d.fossil[a.label]!==d.igt[a.label]&&new RegExp(c(d.fossil[a.label]),"i").test(a.mask)){var b={before:a.mask+""};return a.mask=a.mask.replace(new RegExp(c(d.fossil[a.label]),"ig"),d.igt[a.label]),a.value=a.mask,b.after=a.mask,d.proposedChanges.push(b),a}}),d.cleanedData.push(a)},f=function(a){console.log(a),FieldDB&&FieldDB.FieldDBObject&&"function"==typeof FieldDB.FieldDBObject.bug&&FieldDB.FieldDBObject.bug("There was a problem saving your changes. "+a.reason)},i=0;i<this.datumids.length;i++)console.log(this.datumids.length[i]),b[i]=g.makeCORSRequest({method:"GET",dataType:"json",url:this.url+"/"+this.datumids[i]}),b[i].then(e).fail(f);return h.allSettled(b).then(function(b){a.resolve(d.proposedChanges)}),a.promise}},save:{value:function(){var a=h.defer(),b=this,c=[];for(console.log("Saving cleaned datum...");this.cleanedData.length>0;){var d=this.cleanedData.pop();c.push(g.makeCORSRequest({method:"PUT",dataType:"json",data:d,url:this.url+"/"+d._id}))}return h.allSettled(c).then(function(c){a.resolve(c),b.unsaved=!0}),a.promise}},unsaved:{configurable:!0,get:function(){return this._unsaved?this._unsaved:(this.fossil&&!this.equals({igt:this.fossil})&&(this._unsaved=!0),this._unsaved)},set:function(a){this._unsaved=a}}});var j=function(a,b,c,d){console.log("\tConstructing Lexicon... "),e.apply(this,Array.prototype.slice.call(arguments,1))};j.prototype=Object.create(e.prototype,{constructor:{value:j},sortBy:{value:"morphemes"},bindToView:{value:function(){var a,b,c,e,f,g,h,i,j,k,l,m=this;(a=this.element)&&m.localDOM&&(b=m.localDOM.createElement("ul"),a.appendChild(b),this.forEach(function(a){var n,o;if(!a.igt||"@"!==a.igt.morphemes){c=m.localDOM.createElement("li"),c.__data__=a,c.style.opacity=c.__data__.igt.confidence,c.__data__.igt.morphemes&&(c.id=c.__data__.igt.morphemes),j=m.localDOM.createElement("span"),j.contentEditable="true",j.classList.add("headword"),j.setAttribute("title","CLick to edit the headword of your lexical entry"),c.__data__.igt.headword=c.__data__.igt.headword||c.__data__.igt.morphemes?c.__data__.igt.morphemes:c.__data__.igt.gloss,k=m.localDOM.createElement("button"),k.classList.add("btn"),k.setAttribute("title","Click here to save"),k.innerHTML="Save",l=m.localDOM.createElement("span"),l.classList.add("utteranceContext"),n=m.localDOM.createElement("span"),n.contentEditable="true",n.classList.add("discussion"),n.hidden=!0,c.__data__.igt.discussion=c.__data__.igt.discussion||"Lorem ipsum dolor sit amet, consectetur adipisicing elit, ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",c.ondblclick=function(a){if(a&&a.target&&a.target.__data__){if(a.target.jsonView){a.target.__data__.clean().then(function(b){if(b.length>0){var c=[];b.map(function(a){c.push(a.before+" -> "+a.after)});window.confirm("Would you like to clean this lexical entry? (This will change all examples you see here to have this new information.)\n\n"+c.join("\n"))&&a.target.__data__.save().then(function(a){console.log("Saving success...",a)}).fail(function(a){console.log("Saving failed...",a)})}});n.hidden=!n.hidden,a.target.jsonView.hidden=n.hidden}else a.target.jsonView=m.localDOM.createElement("textarea"),a.target.appendChild(a.target.jsonView),a.target.jsonView.classList.add("lexiconJSON"),n.hidden=!n.hidden;if(a.target.jsonView.hidden){var b;try{b=JSON.parse(a.target.jsonView.innerHTML);for(var c in b)b.hasOwnProperty(c)}catch(b){console.warn("Invalid JSON "+a.target.jsonView.innerHTML,b)}}else a.target.jsonView.innerHTML=JSON.stringify(a.target.__data__.igt,null,2);window.currentlySelectedNode=a.target,console.log(window.currentlySelectedNode.__data__)}},i=m.localDOM.createElement("dl");var p={listItemView:c,saveButtonView:k,headwordView:j,contextsView:l,discussionView:n,fieldListView:i,fieldViews:{},data:void 0};for(o in c.__data__.igt)if(c.__data__.igt.hasOwnProperty(o)){if("discussion"===o||"headword"===o)continue;try{j.classList.add(o+":"+c.__data__.igt[o]),n.classList.add(o+":"+c.__data__.igt[o]),f=m.localDOM.createElement("dt"),e=m.localDOM.createElement("span"),e.innerHTML=o,e.classList.add("fieldlabel"),e.classList.add(o),e.classList.add(c.__data__.igt[o]),f.appendChild(e),i.appendChild(f),g=m.localDOM.createElement("dd"),h=m.localDOM.createElement("span"),h.contentEditable="true",h.classList.add("fieldvalue"),h.classList.add(o),h.classList.add(c.__data__.igt[o]),p.fieldViews[o]=h,g.appendChild(h),i.appendChild(g);var q="fieldViews."+o+".value",r="listItemView.__data__.igt."+o,s={};s[q]={"<-":r};var t={};t[r]={"<->":q},d.defineBindings(p,s),d.defineBindings(p,t)}catch(a){console.warn(a)}}d.defineBindings(p,{"headwordView.value":{"<-":"listItemView.__data__.igt.headword"},"saveButtonView.innerHTML":{"<-":"'Save '+listItemView.__data__.igt.headword"},"saveButtonView.classList.has('btn-danger')":{"<-":"listItemView.__data__.unsaved"},"discussionView.value":{"<-":"listItemView.__data__.igt.discussion"},"contextsView.innerHTML":{"<-":"listItemView.__data__.utteranceContext.join(' ; ')"},"listItemView.title":{"<-":"'Example: '+listItemView.__data__.utteranceContext.join(' Example: ')"},"listItemView.hidden":{"<-":"listItemView.__data__.igt.confidence < self.localDOM.getElementById('lexiconConfidenceThreshold').value / 10"}}),d.defineBindings(p,{"listItemView.__data__.igt.headword":{"<->":"headwordView.value"},"listItemView.__data__.igt.discussion":{"<->":"discussionView.value"}}),c.appendChild(j),c.appendChild(n),c.appendChild(i),c.appendChild(l),c.appendChild(k),b.appendChild(c)}}))}},toJSON:{value:function(){return JSON.stringify(this.toObject(),null,2)}},guessContextSensitiveGlosses:{value:function(a){if(!a.morphemes)return console.warn("There was no morphemes line to guess the gloss from..."),a;var b=[],c=[],d="",e=a.morphemes.split(/ +/),f=function(a){a.igt.morphemes===d&&(console.log(a),c.push(a))};for(var g in e){var h=e[g].split("-"),i=[];for(var j in h)if(h.hasOwnProperty(j)){c=[],d=h[j],this.filter(f);var k="?";if(c&&c.length>0){console.log("Glosses which match: "+h[j],c);try{k=c[0].igt.gloss}catch(a){console.log(c)}}i.push(k)}b.push(i.join("-"))}return a.glossAlternates=a.glossAlternates?a.glossAlternates.concat(b):b,a.gloss=b.join(" "),a}},generatePrecedenceForceDirectedRulesJsonForD3:{value:function(a){var b=[],c={},d={links:b,nodes:c};return this.precedenceGraph=d,d}}});var k=function(a){var b=new j;if(b.precedenceRelations=new f,b.references=new f,a.precedenceRelations)for(var c in a.precedenceRelations)try{delete a.precedenceRelations[c].key.previous.utterance,delete a.precedenceRelations[c].key.subsequent.utterance,a.precedenceRelations[c].key.utteranceContext=a.precedenceRelations[c].key.context.utterance,a.precedenceRelations[c].key.datumid=a.precedenceRelations[c].id,b.add(new i({igt:a.precedenceRelations[c].key.previous,datumids:[a.precedenceRelations[c].key.context.id],utteranceContext:[a.precedenceRelations[c].key.context.utterance],url:a.url})),b.add(new i({igt:a.precedenceRelations[c].key.subsequent,datumids:[a.precedenceRelations[c].key.context.id],utteranceContext:[a.precedenceRelations[c].key.context.utterance],url:a.url})),b.references.add(a.precedenceRelations[c].key.context.id),a.precedenceRelations[c].key.subsequent.morphemes.indexOf("@")===-1&&b.precedenceRelations.add(a.precedenceRelations[c].key)}catch(a){console.warn(a)}for(var d in a)a.hasOwnProperty(d)&&(b[d]=a[d]);return b};a.Lexicon=j,b.Lexicon=j,a.LexiconFactory=k,b.LexiconFactory=k}("object"==typeof c&&c||this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"../../FieldDB/api/CORS":1,"collections/set":17,"collections/sorted-set":23,"frb/bindings":29,"frb/dom":35,q:104}],6:[function(a,b,c){"use strict";function d(a,b){if(!(this instanceof d))return new d(a,b);b=b||Function.noop,this.getDefault=b,this.store=Object.create(null),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./generic-collection")),f=a("./generic-map"),g=a("./listen/property-changes");b.exports=d,d.Dict=d,Object.addEach(d.prototype,e.prototype),Object.addEach(d.prototype,f.prototype),Object.addEach(d.prototype,g.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.getDefault)},d.prototype.assertString=function(a){if("string"!=typeof a)throw new TypeError("key must be a string but Got "+a)},Object.defineProperty(d.prototype,"$__proto__",{writable:!0}),Object.defineProperty(d.prototype,"_hasProto",{get:function(){return this.hasOwnProperty("$__proto__")&&void 0!==this._protoValue}}),Object.defineProperty(d.prototype,"_protoValue",{get:function(){return this.$__proto__},set:function(a){this.$__proto__=a}}),d.prototype.get=function(a,b){return this.assertString(a),"__proto__"===a?this._hasProto?this._protoValue:arguments.length>1?b:this.getDefault(a):a in this.store?this.store[a]:arguments.length>1?b:this.getDefault(a)},d.prototype.set=function(a,b){this.assertString(a);var c="__proto__"===a;return(c?this._hasProto:a in this.store)?(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,c?this._protoValue:this.store[a]),c?this._protoValue=b:this.store[a]=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b),!1):(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,void 0),this.length++,c?this._protoValue=b:this.store[a]=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b),!0)},d.prototype.has=function(a){return this.assertString(a),"__proto__"===a?this._hasProto:a in this.store},d.prototype.delete=function(a){return this.assertString(a),"__proto__"===a?!!this._hasProto&&(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,this._protoValue),this._protoValue=void 0,this.length--,this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0),!0):a in this.store&&(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,this.store[a]),delete this.store[a],this.length--,this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0),!0)},d.prototype.clear=function(){var a;this._hasProto&&(this.dispatchesMapChanges&&this.dispatchBeforeMapChange("__proto__",this._protoValue),this._protoValue=void 0,this.dispatchesMapChanges&&this.dispatchMapChange("__proto__",void 0));for(a in this.store)this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,this.store[a]),delete this.store[a],this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0);this.length=0},d.prototype.reduce=function(a,b,c){this._hasProto&&(b=a.call(c,b,"$__proto__","__proto__",this));var d=this.store;for(var e in this.store)b=a.call(c,b,d[e],e,this);return b},d.prototype.reduceRight=function(a,b,c){var d=this,e=this.store;return b=Object.keys(this.store).reduceRight(function(b,f){return a.call(c,b,e[f],f,d)},b),this._hasProto?a.call(c,b,this._protoValue,"__proto__",d):b},d.prototype.one=function(){var a;for(a in this.store)return this.store[a];return this._protoValue},d.prototype.toJSON=function(){return this.toObject()}},{"./generic-collection":8,"./generic-map":9,"./listen/property-changes":14,"./shim":22}],7:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);b=b||Object.equals,c=c||Object.hash,e=e||Function.noop,this.contentEquals=b,this.contentHash=c,this.getDefault=e;var f=this;this.buckets=new this.Buckets(null,function(){return new f.Bucket}),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./dict")),f=a("./list"),g=a("./generic-collection"),h=a("./generic-set"),i=a("./tree-log"),j=a("./listen/property-changes");Object.prototype.hasOwnProperty;b.exports=d,d.FastSet=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.Buckets=e,d.prototype.Bucket=f,d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentHash,this.getDefault)},d.prototype.has=function(a){var b=this.contentHash(a);return this.buckets.get(b).has(a)},d.prototype.get=function(a,b){if(b)throw new Error("FastSet#get does not support second argument: equals");var c=this.contentHash(a),d=this.buckets;return d.has(c)?d.get(c).get(a):this.getDefault(a)},d.prototype.delete=function(a,b){if(b)throw new Error("FastSet#delete does not support second argument: equals");var c=this.contentHash(a),d=this.buckets;if(d.has(c)){var e=d.get(c);if(e.delete(a))return this.length--,0===e.length&&d.delete(c),!0}return!1},d.prototype.clear=function(){this.buckets.clear(),this.length=0},d.prototype.add=function(a){var b=this.contentHash(a),c=this.buckets;return c.has(b)||c.set(b,new this.Bucket(null,this.contentEquals)),!c.get(b).has(a)&&(c.get(b).add(a),this.length++,!0)},d.prototype.reduce=function(a,b){var c=arguments[2],d=0;return this.buckets.reduce(function(b,e){return e.reduce(function(b,e){return a.call(c,b,e,d++,this)},b,this)},b,this)},d.prototype.one=function(){if(this.length>0)return this.buckets.one().one()},d.prototype.iterate=function(){return this.buckets.values().flatten().iterate()},d.prototype.log=function(a,b,c,d){a=a||i.unicodeSharp,b=b||this.logNode,c||(c=console.log,d=console),c=c.bind(d);var e=this.buckets,f=e.keys();f.forEach(function(g,h){var i,j;h===f.length-1?(i=a.fromAbove,j=" "):0===h?(i=a.branchDown,j=a.strafe):(i=a.fromBoth,j=a.strafe);var k=e.get(g);c.call(d,i+a.through+a.branchDown+" "+g),k.forEach(function(e,f){var g,h;f===k.head.prev?(g=a.fromAbove,h=" "):(g=a.fromBoth,h=a.strafe);var i;b(f,function(b){i?c.call(d,j+" "+h+"  "+b):(c.call(d,j+" "+g+a.through+a.through+b),i=!0)},function(b){c.call(d,j+" "+a.strafe+"  "+b)})})})},d.prototype.logNode=function(a,b){var c=a.value;Object(c)===c?JSON.stringify(c,null,4).split("\n").forEach(function(a){b(" "+a)}):b(" "+c)}},{"./dict":6,"./generic-collection":8,"./generic-set":11,"./list":12,"./listen/property-changes":14,"./shim":22,"./tree-log":24}],8:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. GenericCollection is a mixin.")}b.exports=d,d.EmptyArray=Object.freeze([]),d.prototype.addEach=function(a){if(a&&Object(a)===a)if("function"==typeof a.forEach)a.forEach(this.add,this);else if("number"==typeof a.length)for(var b=0;b<a.length;b++)this.add(a[b],b);else Object.keys(a).forEach(function(b){this.add(a[b],b)},this);else if(a&&"number"==typeof a.length)for(var b=0;b<a.length;b++)this.add(a[b],b);return this},d.prototype.deleteEach=function(a,b){return a.forEach(function(a){this.delete(a,b)},this),this},d.prototype.forEach=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){a.call(b,d,e,f,g)},void 0)},d.prototype.map=function(a){var b=arguments[1],c=[];return this.reduce(function(d,e,f,g,h){c.push(a.call(b,e,f,g,h))},void 0),c},d.prototype.enumerate=function(a){null==a&&(a=0);var b=[];return this.reduce(function(c,d){b.push([a++,d])},void 0),b},d.prototype.group=function(a,b,c){c=c||Object.equals;var d=[],e=[];return this.forEach(function(f,g,h){var i,g=a.call(b,f,g,h),j=e.indexOf(g,c);j===-1?(i=[],d.push([g,i]),e.push(g)):i=d[j][1],i.push(f)}),d},d.prototype.toArray=function(){return this.map(Function.identity)},d.prototype.toObject=function(){var a={};return this.reduce(function(b,c,d){a[d]=c},void 0),a},d.prototype.filter=function(a){var b=arguments[1],c=this.constructClone();return this.reduce(function(d,e,f,g,h){a.call(b,e,f,g,h)&&c.add(e,f)},void 0),c},d.prototype.every=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){return c&&a.call(b,d,e,f,g)},!0)},d.prototype.some=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){return c||a.call(b,d,e,f,g)},!1)},d.prototype.all=function(){return this.every(Boolean)},d.prototype.any=function(){return this.some(Boolean)},d.prototype.min=function(a){a=a||this.contentCompare||Object.compare;var b=!0;return this.reduce(function(c,d){return b?(b=!1,d):a(d,c)<0?d:c},void 0)},d.prototype.max=function(a){a=a||this.contentCompare||Object.compare;var b=!0;return this.reduce(function(c,d){return b?(b=!1,d):a(d,c)>0?d:c},void 0)},d.prototype.sum=function(a){return a=void 0===a?0:a,this.reduce(function(a,b){return a+b},a)},d.prototype.average=function(a){var b=void 0===a?0:a,c=void 0===a?0:a;return this.reduce(function(a,d){b+=d,c+=1},void 0),b/c},d.prototype.concat=function(){for(var a=this.constructClone(this),b=0;b<arguments.length;b++)a.addEach(arguments[b]);return a},d.prototype.flatten=function(){var a=this;return this.reduce(function(b,c){return c.forEach(function(a){this.push(a)},b,a),b},[])},d.prototype.zip=function(){var a=Array.prototype.slice.call(arguments);return a.unshift(this),Array.unzip(a)},d.prototype.join=function(a){return this.reduce(function(b,c){return void 0===b?c:b+a+c},void 0)},d.prototype.sorted=function(a,b,c){return a=a||this.contentCompare||Object.compare,a.by?(b=a.by,a=a.compare||this.contentCompare||Object.compare):b=b||Function.identity,void 0===c&&(c=1),this.map(function(a){return{by:b(a),value:a}}).sort(function(b,d){return a(b.by,d.by)*c}).map(function(a){return a.value})},d.prototype.reversed=function(){return this.constructClone(this).reverse()},d.prototype.clone=function(a,b){if(void 0===a)a=1/0;else if(0===a)return this;var c=this.constructClone();return this.forEach(function(d,e){c.add(Object.clone(d,a-1,b),e)},this),c},d.prototype.only=function(){if(1===this.length)return this.one()},d.prototype.iterator=function(){return this.iterate.apply(this,arguments)},a("./shim-array")},{"./shim-array":18}],9:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. GenericMap is a mixin.")}function e(a,b){this.key=a,this.value=b}var f=a("./shim-object"),g=a("./listen/map-changes"),h=a("./listen/property-changes");b.exports=d,f.addEach(d.prototype,g.prototype),f.addEach(d.prototype,h.prototype),d.prototype.isMap=!0,d.prototype.addEach=function(a){if(a&&f(a)===a)if("function"==typeof a.forEach)a.isMap===!0?a.forEach(function(a,b){this.set(b,a)},this):a.forEach(function(a){this.set(a[0],a[1])},this);else if("number"==typeof a.length)for(var b=0;b<a.length;b++)this.add(a[b],b);else f.keys(a).forEach(function(b){this.set(b,a[b])},this);else if(a&&"number"==typeof a.length)for(var b=0;b<a.length;b++)this.add(a[b],b);return this},d.prototype.get=function(a,b){var c=this.store.get(new this.Item(a));return c?c.value:arguments.length>1?b:this.getDefault(a)},d.prototype.set=function(a,b){var c=new this.Item(a,b),d=this.store.get(c),e=!1;return d?(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,d.value),d.value=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b)):(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,void 0),this.store.add(c)&&(this.length++,e=!0),this.dispatchesMapChanges&&this.dispatchMapChange(a,b)),e},d.prototype.add=function(a,b){return this.set(b,a)},d.prototype.has=function(a){return this.store.has(new this.Item(a))},d.prototype.delete=function(a){var b=new this.Item(a);if(this.store.has(b)){var c=this.store.get(b).value;return this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,c),this.store.delete(b),this.length--,this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0),!0}return!1},d.prototype.clear=function(){var a;this.dispatchesMapChanges&&(this.forEach(function(a,b){this.dispatchBeforeMapChange(b,a)},this),a=this.keys()),this.store.clear(),this.length=0,this.dispatchesMapChanges&&a.forEach(function(a){this.dispatchMapChange(a)},this)},d.prototype.reduce=function(a,b,c){return this.store.reduce(function(b,d){return a.call(c,b,d.value,d.key,this)},b,this)},d.prototype.reduceRight=function(a,b,c){return this.store.reduceRight(function(b,d){return a.call(c,b,d.value,d.key,this)},b,this)},d.prototype.keys=function(){return this.map(function(a,b){return b})},d.prototype.values=function(){return this.map(Function.identity)},d.prototype.entries=function(){return this.map(function(a,b){return[b,a]})},d.prototype.items=function(){return this.entries()},d.prototype.equals=function(a,b){return b=b||f.equals,this===a||(a&&"function"==typeof a.every?a.length===this.length&&a.every(function(a,c){return b(this.get(c),a)},this):f.keys(a).length===this.length&&f.keys(a).every(function(c){return b(this.get(c),a[c])},this))},d.prototype.toJSON=function(){return this.entries()},d.prototype.Item=e,e.prototype.equals=function(a){return f.equals(this.key,a.key)&&f.equals(this.value,a.value)},e.prototype.compare=function(a){return f.compare(this.key,a.key)}},{"./listen/map-changes":13,"./listen/property-changes":14,"./shim-object":20}],10:[function(a,b,c){function d(){throw new Error("Can't construct. GenericOrder is a mixin.")}var e=a("./shim-object");b.exports=d,d.prototype.equals=function(a,b){if(b=b||this.contentEquals||e.equals,this===a)return!0;if(!a)return!1;return this.length===a.length&&this.zip(a).every(function(a){return b(a[0],a[1])})},d.prototype.compare=function(a,b){if(b=b||this.contentCompare||e.compare,this===a)return 0;if(!a)return 1;var c=Math.min(this.length,a.length),d=this.zip(a).reduce(function(a,d,e){return 0===a?e>=c?a:b(d[0],d[1]):a},0);return 0===d?this.length-a.length:d},d.prototype.toJSON=function(){return this.toArray()}},{"./shim-object":20}],11:[function(a,b,c){function d(){throw new Error("Can't construct. GenericSet is a mixin.")}b.exports=d,d.prototype.isSet=!0,d.prototype.union=function(a){var b=this.constructClone(this);return b.addEach(a),b},d.prototype.intersection=function(a){return this.constructClone(this.filter(function(b){return a.has(b)}))},d.prototype.difference=function(a){var b=this.constructClone(this);return b.deleteEach(a),b},d.prototype.symmetricDifference=function(a){var b=this.union(a),c=this.intersection(a);return b.difference(c)},d.prototype.deleteAll=function(a){return+this.delete(a)},d.prototype.equals=function(a,b){var c=this;return a&&"function"==typeof a.reduce&&this.length===a.length&&a.reduce(function(a,d){return a&&c.has(d,b)},!0)},d.prototype.toJSON=function(){return this.toArray()},d.prototype.contains=function(a){return this.has(a)},d.prototype.remove=function(a){return this.delete(a)},d.prototype.toggle=function(a){this.has(a)?this.delete(a):this.add(a)}},{}],12:[function(a,b,c){"use strict";function d(a,b,c){if(!(this instanceof d))return new d(a,b,c);var e=this.head=new this.Node;e.next=e,e.prev=e,this.contentEquals=b||Object.equals,this.getDefault=c||Function.noop,this.length=0,this.addEach(a)}function e(a){this.head=a,this.at=a.next}function f(a){this.value=a,this.prev=null,this.next=null}b.exports=d;var g=(a("./shim"),a("./generic-collection")),h=a("./generic-order"),i=a("./listen/property-changes"),j=a("./listen/range-changes");d.List=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.getDefault)},d.prototype.find=function(a,b,c){b=b||this.contentEquals;for(var d=this.head,e=this.scan(c,d.next);e!==d;){if(b(e.value,a))return e;e=e.next}},d.prototype.findLast=function(a,b,c){b=b||this.contentEquals;for(var d=this.head,e=this.scan(c,d.prev);e!==d;){if(b(e.value,a))return e;e=e.prev}},d.prototype.has=function(a,b){return!!this.find(a,b)},d.prototype.get=function(a,b){var c=this.find(a,b);return c?c.value:this.getDefault(a)},d.prototype.delete=function(a,b){var c=this.findLast(a,b);if(c){if(this.dispatchesRangeChanges){var d=[],e=[a];this.dispatchBeforeRangeChange(d,e,c.index)}return c.delete(),this.length--,this.dispatchesRangeChanges&&(this.updateIndexes(c.next,c.index),this.dispatchRangeChange(d,e,c.index)),!0}return!1},d.prototype.deleteAll=function(a,b){b=b||this.contentEquals;for(var c=this.head,d=c.next,e=0;d!==c;)b(a,d.value)&&(d.delete(),e++),d=d.next;return this.length-=e,e},d.prototype.clear=function(){var a,b;this.dispatchesRangeChanges&&(b=this.toArray(),a=[],this.dispatchBeforeRangeChange(a,b,0)),this.head.next=this.head.prev=this.head,this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange(a,b,0)},d.prototype.add=function(a){var b=new this.Node(a);return this.dispatchesRangeChanges&&(b.index=this.length,this.dispatchBeforeRangeChange([a],[],b.index)),this.head.addBefore(b),this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],b.index),!0},d.prototype.push=function(){var a=this.head;if(this.dispatchesRangeChanges){var b=Array.prototype.slice.call(arguments),c=[],d=this.length;this.dispatchBeforeRangeChange(b,c,d);var e=this.head.prev}for(var f=0;f<arguments.length;f++){var g=arguments[f],h=new this.Node(g);a.addBefore(h)}this.length+=arguments.length,this.dispatchesRangeChanges&&(this.updateIndexes(e.next,void 0===e.index?0:e.index+1),this.dispatchRangeChange(b,c,d))},d.prototype.unshift=function(){if(this.dispatchesRangeChanges){
+var a=Array.prototype.slice.call(arguments),b=[];this.dispatchBeforeRangeChange(a,b,0)}for(var c=this.head,d=0;d<arguments.length;d++){var e=arguments[d],f=new this.Node(e);c.addAfter(f),c=f}this.length+=arguments.length,this.dispatchesRangeChanges&&(this.updateIndexes(this.head.next,0),this.dispatchRangeChange(a,b,0))},d.prototype.pop=function(){var a,b=this.head;if(b.prev!==b){if(a=b.prev.value,this.dispatchesRangeChanges){var c=[],d=[a],e=this.length-1;this.dispatchBeforeRangeChange(c,d,e)}b.prev.delete(),this.length--,this.dispatchesRangeChanges&&this.dispatchRangeChange(c,d,e)}return a},d.prototype.shift=function(){var a,b=this.head;if(b.prev!==b){if(a=b.next.value,this.dispatchesRangeChanges){var c=[],d=[a];this.dispatchBeforeRangeChange(c,d,0)}b.next.delete(),this.length--,this.dispatchesRangeChanges&&(this.updateIndexes(this.head.next,0),this.dispatchRangeChange(c,d,0))}return a},d.prototype.peek=function(){if(this.head!==this.head.next)return this.head.next.value},d.prototype.poke=function(a){this.head!==this.head.next?this.head.next.value=a:this.push(a)},d.prototype.one=function(){return this.peek()},d.prototype.scan=function(a,b){var c=this.head;if("number"==typeof a){var d=a;if(d>=0)for(a=c.next;d&&(d--,(a=a.next)!=c););else for(a=c;d<0&&(d++,(a=a.prev)!=c););return a}return a||b},d.prototype.slice=function(a,b){var c=[],d=this.head;for(a=this.scan(a,d.next),b=this.scan(b,d);a!==b&&a!==d;)c.push(a.value),a=a.next;return c},d.prototype.splice=function(a,b){return this.swap(a,b,Array.prototype.slice.call(arguments,2))},d.prototype.swap=function(a,b,c){var d=a;a=this.scan(a,this.head),null==b&&(b=1/0),c=Array.from(c);for(var e=[],f=a;b--&&b>=0&&f!==this.head;)e.push(f.value),f=f.next;var g,h;this.dispatchesRangeChanges&&(g=a===this.head?this.length:a.prev===this.head?0:a.index,h=a.prev,this.dispatchBeforeRangeChange(c,e,g));for(var f=a,i=0,f=a;i<e.length;i++,f=f.next)f.delete();null==d&&f===this.head&&(f=this.head.next);for(var i=0;i<c.length;i++){var j=new this.Node(c[i]);f.addBefore(j)}return this.length+=c.length-e.length,this.dispatchesRangeChanges&&(a===this.head?this.updateIndexes(this.head.next,0):this.updateIndexes(h.next,h.index+1),this.dispatchRangeChange(c,e,g)),e},d.prototype.reverse=function(){if(this.dispatchesRangeChanges){var a=this.toArray(),b=a.reversed();this.dispatchBeforeRangeChange(b,a,0)}var c=this.head;do{var d=c.next;c.next=c.prev,c.prev=d,c=c.next}while(c!==this.head);return this.dispatchesRangeChanges&&this.dispatchRangeChange(b,a,0),this},d.prototype.sort=function(){this.swap(0,this.length,this.sorted())},d.prototype.reduce=function(a,b){for(var c=arguments[2],d=this.head,e=d.next;e!==d;)b=a.call(c,b,e.value,e,this),e=e.next;return b},d.prototype.reduceRight=function(a,b){for(var c=arguments[2],d=this.head,e=d.prev;e!==d;)b=a.call(c,b,e.value,e,this),e=e.prev;return b},d.prototype.updateIndexes=function(a,b){for(;a!==this.head;)a.index=b++,a=a.next},d.prototype.makeObservable=function(){this.head.index=-1,this.updateIndexes(this.head.next,0),this.dispatchesRangeChanges=!0},d.prototype.iterate=function(){return new e(this.head)},e.prototype.next=function(){if(this.at===this.head)throw StopIteration;var a=this.at.value;return this.at=this.at.next,a},d.prototype.Node=f,f.prototype.delete=function(){this.prev.next=this.next,this.next.prev=this.prev},f.prototype.addBefore=function(a){var b=this.prev;this.prev=a,a.prev=b,b.next=a,a.next=this},f.prototype.addAfter=function(a){var b=this.next;this.next=a,a.next=b,b.prev=a,a.prev=this}},{"./generic-collection":8,"./generic-order":10,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22}],13:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. MapChanges is a mixin.")}var e=a("weak-map"),f=a("../list");b.exports=d;var g=(Object.prototype.hasOwnProperty,new e),h=null;d.prototype.getAllMapChangeDescriptors=function(){return g.has(this)||(h||(h=a("../dict")),g.set(this,h())),g.get(this)},d.prototype.getMapChangeDescriptor=function(a){var b=this.getAllMapChangeDescriptors();return a=a||"",b.has(a)||b.set(a,{willChangeListeners:new f,changeListeners:new f}),b.get(a)},d.prototype.addMapChangeListener=function(a,b,c){!this.isObservable&&this.makeObservable&&this.makeObservable();var d,e=this.getMapChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners,d.push(a),Object.defineProperty(this,"dispatchesMapChanges",{value:!0,writable:!0,configurable:!0,enumerable:!1});var f=this;return function(){f&&(f.removeMapChangeListener(a,b,c),f=null)}},d.prototype.removeMapChangeListener=function(a,b,c){var d,e=this.getMapChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners;var f=d.findLast(a);if(!f)throw new Error("Can't remove map change listener: does not exist: token "+JSON.stringify(b));f.delete()},d.prototype.dispatchMapChange=function(a,b,c){var d="Map"+(c?"WillChange":"Change");this.getAllMapChangeDescriptors().forEach(function(e,f){if(!e.isActive){e.isActive=!0;var g;g=c?e.willChangeListeners:e.changeListeners;var h="handle"+(f.slice(0,1).toUpperCase()+f.slice(1))+d;try{g.forEach(function(c){if(c[h])c[h](b,a,this);else{if(!c.call)throw new Error("Handler "+c+" has no method "+h+" and is not callable");c.call(c,b,a,this)}},this)}finally{e.isActive=!1}}},this)},d.prototype.addBeforeMapChangeListener=function(a,b){return this.addMapChangeListener(a,b,!0)},d.prototype.removeBeforeMapChangeListener=function(a,b){return this.removeMapChangeListener(a,b,!0)},d.prototype.dispatchBeforeMapChange=function(a,b){return this.dispatchMapChange(a,b,!0)}},{"../dict":6,"../list":12,"weak-map":16}],14:[function(a,b,c){function d(){throw new Error("This is an abstract interface. Mix it. Don't construct it")}function e(a,b,c,d){var e,f,g,h=a.active,i=a.current,j=i.length,k=j;for(h.length>j&&(h.length=j);j--;)h[j]=i[j];for(f=0;f<k;f++)if(g=h[f],!f||i.indexOf(g)>=0){if(e=g[a.specificHandlerMethodName]||g[a.genericHandlerMethodName]||g,!e.call)throw new Error("No event listener for "+a.specificHandlerName+" or "+a.genericHandlerName+" or call on "+e);e.call(g,c,b,d)}}a("../shim");var f=Object.prototype.hasOwnProperty;b.exports=d,d.debug=!0,d.prototype.getOwnPropertyChangeDescriptor=function(a){this.__propertyChangeListeners__||Object.defineProperty(this,"__propertyChangeListeners__",{value:{},enumerable:!1,configurable:!0,writable:!0});var b=this.__propertyChangeListeners__;if(!f.call(b,a)){var c=String(a);c=c&&c[0].toUpperCase()+c.slice(1),b[a]={willChangeListeners:{current:[],active:[],specificHandlerMethodName:"handle"+c+"WillChange",genericHandlerMethodName:"handlePropertyWillChange"},changeListeners:{current:[],active:[],specificHandlerMethodName:"handle"+c+"Change",genericHandlerMethodName:"handlePropertyChange"}}}return b[a]},d.prototype.hasOwnPropertyChangeDescriptor=function(a){if(!this.__propertyChangeListeners__)return!1;if(!a)return!0;var b=this.__propertyChangeListeners__;return!!f.call(b,a)},d.prototype.addOwnPropertyChangeListener=function(a,b,c){this.makeObservable&&!this.isObservable&&this.makeObservable();var e,f=d.getOwnPropertyChangeDescriptor(this,a);e=c?f.willChangeListeners:f.changeListeners,d.makePropertyObservable(this,a),e.current.push(b);var g=this;return function(){d.removeOwnPropertyChangeListener(g,a,b,c),g=null}},d.prototype.addBeforeOwnPropertyChangeListener=function(a,b){return d.addOwnPropertyChangeListener(this,a,b,!0)},d.prototype.removeOwnPropertyChangeListener=function(a,b,c){var e,f=d.getOwnPropertyChangeDescriptor(this,a);e=c?f.willChangeListeners:f.changeListeners;var g=e.current.lastIndexOf(b);if(g===-1)throw new Error("Can't remove property change listener: does not exist: property name"+JSON.stringify(a));e.current.splice(g,1)},d.prototype.removeBeforeOwnPropertyChangeListener=function(a,b){return d.removeOwnPropertyChangeListener(this,a,b,!0)},d.prototype.dispatchOwnPropertyChange=function(a,b,c){var f,g=d.getOwnPropertyChangeDescriptor(this,a);if(!g.isActive){g.isActive=!0,f=c?g.willChangeListeners:g.changeListeners;try{e(f,a,b,this)}finally{g.isActive=!1}}},d.prototype.dispatchBeforeOwnPropertyChange=function(a,b){return d.dispatchOwnPropertyChange(this,a,b,!0)},d.prototype.makePropertyObservable=function(a){var b=this.__overriddenPropertyDescriptors__;if(b){if(f.call(b,a))return}else{if(Array.isArray(this))return;if(!Object.isExtensible(this))throw new Error("Can't make property "+JSON.stringify(a)+" observable on "+this+" because object is not extensible");b={},Object.defineProperty(this,"__overriddenPropertyDescriptors__",{value:b,enumerable:!1,writable:!0,configurable:!0})}var c;"object"==typeof this.__state__?c=this.__state__:(c={},Object.defineProperty(this,"__state__",{value:c,writable:!0,enumerable:!1})),c[a]=this[a];var d,g=this;do{if(d=Object.getOwnPropertyDescriptor(g,a))break;g=Object.getPrototypeOf(g)}while(g);if(d){if(!d.configurable)return;if(!d.writable&&!d.set)return}else d={value:void 0,enumerable:!0,writable:!0,configurable:!0};b[a]=d;var h;h="value"in d?{get:function(){return d.value},set:function(b){var f,g;if(b!==d.value){if(f=this.__propertyChangeListeners__[a],!(g=f.isActive)){f.isActive=!0;try{e(f.willChangeListeners,a,d.value,this)}finally{}}if(d.value=b,c[a]=b,!g)try{e(f.changeListeners,a,b,this)}finally{f.isActive=!1}}},enumerable:d.enumerable,configurable:!0}:{get:d.get,set:function(b){var f,g,h=this[a];if(d.set.call(this,b),(b=this[a])!==h){if(f=this.__propertyChangeListeners__[a],!(g=f.isActive)){f.isActive=!0;try{e(f.willChangeListeners,a,h,this)}finally{}}if(c[a]=b,!g)try{e(f.changeListeners,a,b,this)}finally{f.isActive=!1}}},enumerable:d.enumerable,configurable:!0},Object.defineProperty(this,a,h)},d.getOwnPropertyChangeDescriptor=function(a,b){return a.getOwnPropertyChangeDescriptor?a.getOwnPropertyChangeDescriptor(b):d.prototype.getOwnPropertyChangeDescriptor.call(a,b)},d.hasOwnPropertyChangeDescriptor=function(a,b){return a.hasOwnPropertyChangeDescriptor?a.hasOwnPropertyChangeDescriptor(b):d.prototype.hasOwnPropertyChangeDescriptor.call(a,b)},d.addOwnPropertyChangeListener=function(a,b,c,e){if(Object.isObject(a))return a.addOwnPropertyChangeListener?a.addOwnPropertyChangeListener(b,c,e):d.prototype.addOwnPropertyChangeListener.call(a,b,c,e)},d.removeOwnPropertyChangeListener=function(a,b,c,e){if(Object.isObject(a))return a.removeOwnPropertyChangeListener?a.removeOwnPropertyChangeListener(b,c,e):d.prototype.removeOwnPropertyChangeListener.call(a,b,c,e)},d.dispatchOwnPropertyChange=function(a,b,c,e){if(Object.isObject(a))return a.dispatchOwnPropertyChange?a.dispatchOwnPropertyChange(b,c,e):d.prototype.dispatchOwnPropertyChange.call(a,b,c,e)},d.addBeforeOwnPropertyChangeListener=function(a,b,c){return d.addOwnPropertyChangeListener(a,b,c,!0)},d.removeBeforeOwnPropertyChangeListener=function(a,b,c){return d.removeOwnPropertyChangeListener(a,b,c,!0)},d.dispatchBeforeOwnPropertyChange=function(a,b,c){return d.dispatchOwnPropertyChange(a,b,c,!0)},d.makePropertyObservable=function(a,b){return a.makePropertyObservable?a.makePropertyObservable(b):d.prototype.makePropertyObservable.call(a,b)}},{"../shim":22}],15:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. RangeChanges is a mixin.")}var e=a("weak-map"),f=a("../dict"),g=new e;b.exports=d,d.prototype.getAllRangeChangeDescriptors=function(){return g.has(this)||g.set(this,f()),g.get(this)},d.prototype.getRangeChangeDescriptor=function(a){var b=this.getAllRangeChangeDescriptors();return a=a||"",b.has(a)||b.set(a,{isActive:!1,changeListeners:[],willChangeListeners:[]}),b.get(a)},d.prototype.addRangeChangeListener=function(a,b,c){!this.isObservable&&this.makeObservable&&this.makeObservable();var d,e=this.getRangeChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners,d.push(a),Object.defineProperty(this,"dispatchesRangeChanges",{value:!0,writable:!0,configurable:!0,enumerable:!1});var f=this;return function(){f&&(f.removeRangeChangeListener(a,b,c),f=null)}},d.prototype.removeRangeChangeListener=function(a,b,c){var d,e=this.getRangeChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners;var f=d.lastIndexOf(a);if(f===-1)throw new Error("Can't remove range change listener: does not exist: token "+JSON.stringify(b));d.splice(f,1)},d.prototype.dispatchRangeChange=function(a,b,c,d){var e="Range"+(d?"WillChange":"Change");this.getAllRangeChangeDescriptors().forEach(function(f,g){if(!f.isActive){f.isActive=!0;var h;h=d?f.willChangeListeners:f.changeListeners;var i="handle"+(g.slice(0,1).toUpperCase()+g.slice(1))+e;try{h.slice().forEach(function(e){if(!(h.indexOf(e)<0))if(e[i])e[i](a,b,c,this,d);else{if(!e.call)throw new Error("Handler "+e+" has no method "+i+" and is not callable");e.call(this,a,b,c,this,d)}},this)}finally{f.isActive=!1}}},this)},d.prototype.addBeforeRangeChangeListener=function(a,b){return this.addRangeChangeListener(a,b,!0)},d.prototype.removeBeforeRangeChangeListener=function(a,b){return this.removeRangeChangeListener(a,b,!0)},d.prototype.dispatchBeforeRangeChange=function(a,b,c){return this.dispatchRangeChange(a,b,c,!0)}},{"../dict":6,"weak-map":16}],16:[function(a,b,c){!function(){"use strict";function a(b){b.permitHostObjects___&&b.permitHostObjects___(a)}function c(a){return!(a.substr(0,n.length)==n&&"___"===a.substr(a.length-3))}function d(a){if(a!==Object(a))throw new TypeError("Not an object: "+a);var b=a[o];if(b&&b.key===a)return b;if(m(a)){b={key:a};try{return l(a,o,{value:b,writable:!1,enumerable:!1,configurable:!1}),b}catch(a){return}}}function e(a){return a.prototype=null,Object.freeze(a)}function f(){s||"undefined"==typeof console||(s=!0,console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future."))}if("undefined"==typeof ses||!ses.ok||ses.ok()){"undefined"!=typeof ses&&(ses.weakMapPermitHostObjects=a);var g=!1;if("function"==typeof WeakMap){var h=WeakMap;if("undefined"!=typeof navigator&&/Firefox/.test(navigator.userAgent));else{var i=new h,j=Object.freeze({});if(i.set(j,1),1===i.get(j))return void(b.exports=WeakMap);g=!0}}var k=(Object.prototype.hasOwnProperty,Object.getOwnPropertyNames),l=Object.defineProperty,m=Object.isExtensible,n="weakmap:",o=n+"ident:"+Math.random()+"___";if("undefined"!=typeof crypto&&"function"==typeof crypto.getRandomValues&&"function"==typeof ArrayBuffer&&"function"==typeof Uint8Array){var p=new ArrayBuffer(25),q=new Uint8Array(p);crypto.getRandomValues(q),o=n+"rand:"+Array.prototype.map.call(q,function(a){return(a%36).toString(36)}).join("")+"___"}if(l(Object,"getOwnPropertyNames",{value:function(a){return k(a).filter(c)}}),"getPropertyNames"in Object){var r=Object.getPropertyNames;l(Object,"getPropertyNames",{value:function(a){return r(a).filter(c)}})}!function(){var a=Object.freeze;l(Object,"freeze",{value:function(b){return d(b),a(b)}});var b=Object.seal;l(Object,"seal",{value:function(a){return d(a),b(a)}});var c=Object.preventExtensions;l(Object,"preventExtensions",{value:function(a){return d(a),c(a)}})}();var s=!1,t=0,u=function(){function a(a,b){var c,e=d(a);return e?j in e?e[j]:b:(c=h.indexOf(a),c>=0?i[c]:b)}function b(a){var b=d(a);return b?j in b:h.indexOf(a)>=0}function c(a,b){var c,e=d(a);return e?e[j]=b:(c=h.indexOf(a),c>=0?i[c]=b:(c=h.length,i[c]=b,h[c]=a)),this}function g(a){var b,c,e=d(a);return e?j in e&&delete e[j]:!((b=h.indexOf(a))<0)&&(c=h.length-1,h[b]=void 0,i[b]=i[c],h[b]=h[c],h.length=c,i.length=c,!0)}this instanceof u||f();var h=[],i=[],j=t++;return Object.create(u.prototype,{get___:{value:e(a)},has___:{value:e(b)},set___:{value:e(c)},delete___:{value:e(g)}})};u.prototype=Object.create(Object.prototype,{get:{value:function(a,b){return this.get___(a,b)},writable:!0,configurable:!0},has:{value:function(a){return this.has___(a)},writable:!0,configurable:!0},set:{value:function(a,b){return this.set___(a,b)},writable:!0,configurable:!0},delete:{value:function(a){return this.delete___(a)},writable:!0,configurable:!0}}),"function"==typeof h?function(){function c(){function b(a,b){return k?j.has(a)?j.get(a):k.get___(a,b):j.get(a,b)}function c(a){return j.has(a)||!!k&&k.has___(a)}function d(a){var b=!!j.delete(a);return k?k.delete___(a)||b:b}this instanceof u||f();var i,j=new h,k=void 0,l=!1;return i=g?function(a,b){return j.set(a,b),j.has(a)||(k||(k=new u),k.set(a,b)),this}:function(a,b){if(l)try{j.set(a,b)}catch(c){k||(k=new u),k.set___(a,b)}else j.set(a,b);return this},Object.create(u.prototype,{get___:{value:e(b)},has___:{value:e(c)},set___:{value:e(i)},delete___:{value:e(d)},permitHostObjects___:{value:e(function(b){if(b!==a)throw new Error("bogus call to permitHostObjects___");l=!0})}})}g&&"undefined"!=typeof Proxy&&(Proxy=void 0),c.prototype=u.prototype,b.exports=c,Object.defineProperty(WeakMap.prototype,"constructor",{value:WeakMap,enumerable:!1,configurable:!0,writable:!0})}():("undefined"!=typeof Proxy&&(Proxy=void 0),b.exports=u)}}()},{}],17:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);b=b||Object.equals,c=c||Object.hash,e=e||Function.noop,this.contentEquals=b,this.contentHash=c,this.getDefault=e,this.order=new this.Order(void 0,b),this.store=new this.Store(void 0,function(a,c){return b(a.value,c.value)},function(a){return c(a.value)}),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./list")),f=a("./fast-set"),g=a("./generic-collection"),h=a("./generic-set"),i=a("./listen/property-changes"),j=a("./listen/range-changes");b.exports=d,d.Set=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.Order=e,d.prototype.Store=f,d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentHash,this.getDefault)},d.prototype.has=function(a){var b=new this.order.Node(a);return this.store.has(b)},d.prototype.get=function(a,b){if(b)throw new Error("Set#get does not support second argument: equals");var c=new this.order.Node(a);return c=this.store.get(c),c?c.value:this.getDefault(a)},d.prototype.add=function(a){var b=new this.order.Node(a);if(!this.store.has(b)){var c=this.length;return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],c),this.order.add(a),b=this.order.head.prev,this.store.add(b),this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],c),!0}return!1},d.prototype.delete=function(a,b){if(b)throw new Error("Set#delete does not support second argument: equals");var c=new this.order.Node(a);return!!this.store.has(c)&&(c=this.store.get(c),this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([],[a],c.index),this.store.delete(c),this.order.splice(c,1),this.length--,this.dispatchesRangeChanges&&this.dispatchRangeChange([],[a],c.index),!0)},d.prototype.pop=function(){if(this.length){var a=this.order.head.prev.value;return this.delete(a),a}},d.prototype.shift=function(){if(this.length){var a=this.order.head.next.value;return this.delete(a),a}},d.prototype.one=function(){if(this.length>0)return this.store.one().value},d.prototype.clear=function(){var a;this.dispatchesRangeChanges&&(a=this.toArray(),this.dispatchBeforeRangeChange([],a,0)),this.store.clear(),this.order.clear(),this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange([],a,0)},d.prototype.reduce=function(a,b){var c=arguments[2],d=0;return this.order.reduce(function(b,e){return a.call(c,b,e,d++,this)},b,this)},d.prototype.reduceRight=function(a,b){var c=arguments[2],d=this.order,e=this.length-1;return d.reduceRight(function(b,d){return a.call(c,b,d,e--,this)},b,this)},d.prototype.iterate=function(){return this.order.iterate()},d.prototype.log=function(){var a=this.store;return a.log.apply(a,arguments)},d.prototype.makeObservable=function(){this.order.makeObservable()}},{"./fast-set":7,"./generic-collection":8,"./generic-set":11,"./list":12,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22}],18:[function(a,b,c){"use strict";function d(a,b){Object.defineProperty(Array.prototype,a,{value:b,writable:!0,configurable:!0,enumerable:!1})}function e(a,b,c){this.array=a,this.start=null==b?0:b,this.end=c}var f=(a("./shim-function"),a("./generic-collection")),g=a("./generic-order"),h=a("weak-map");b.exports=Array;var i=Array.prototype.splice,j=Array.prototype.slice;Array.empty=[],Object.freeze&&Object.freeze(Array.empty),Array.from=function(a){var b=[];return b.addEach(a),b},Array.unzip=function(a){for(var b=[],c=1/0,d=0;d<a.length;d++){var e=a[d];a[d]=e.toArray(),e.length<c&&(c=e.length)}for(var d=0;d<a.length;d++)for(var e=a[d],f=0;f<e.length;f++)f<c&&f in e&&(b[f]=b[f]||[],b[f][d]=e[f]);return b},d("addEach",f.prototype.addEach),d("deleteEach",f.prototype.deleteEach),d("toArray",f.prototype.toArray),d("toObject",f.prototype.toObject),d("all",f.prototype.all),d("any",f.prototype.any),d("min",f.prototype.min),d("max",f.prototype.max),d("sum",f.prototype.sum),d("average",f.prototype.average),d("only",f.prototype.only),d("flatten",f.prototype.flatten),d("zip",f.prototype.zip),d("enumerate",f.prototype.enumerate),d("group",f.prototype.group),d("sorted",f.prototype.sorted),d("reversed",f.prototype.reversed),d("constructClone",function(a){var b=new this.constructor;return b.addEach(a),b}),d("has",function(a,b){return this.find(a,b)!==-1}),d("get",function(a,b){if(+a!==a)throw new Error("Indicies must be numbers");return!a in this?b:this[a]}),d("set",function(a,b){return this[a]=b,!0}),d("add",function(a){return this.push(a),!0}),d("delete",function(a,b){var c=this.find(a,b);return c!==-1&&(this.splice(c,1),!0)}),d("deleteAll",function(a,b){b=b||this.contentEquals||Object.equals;for(var c=0,d=0;d<this.length;)b(a,this[d])?(this.swap(d,1),c++):d++;return c}),d("find",function(a,b){b=b||this.contentEquals||Object.equals;for(var c=0;c<this.length;c++)if(c in this&&b(a,this[c]))return c;return-1}),d("findLast",function(a,b){b=b||this.contentEquals||Object.equals;var c=this.length;do{if(--c in this&&b(this[c],a))return c}while(c>0);return-1}),d("swap",function(a,b,c){var d,e,f,g,h;if(a>this.length&&(this.length=a),void 0!==c){if(d=[a,b],Array.isArray(c)||(c=j.call(c)),f=0,(e=c.length)<1e3){for(f;f<e;f++)d[f+2]=c[f];return i.apply(this,d)}for(h=i.apply(this,d),f;f<e;){for(d=[a+f,0],g=2;g<1002&&f<e;g++,f++)d[g]=c[f];i.apply(this,d)}return h}return void 0!==b?i.call(this,a,b):void 0!==a?i.call(this,a):[]}),d("peek",function(){return this[0]}),d("poke",function(a){this.length>0&&(this[0]=a)}),d("peekBack",function(){if(this.length>0)return this[this.length-1]}),d("pokeBack",function(a){this.length>0&&(this[this.length-1]=a)}),d("one",function(){for(var a in this)if(Object.owns(this,a))return this[a]}),Array.prototype.clear||d("clear",function(){return this.length=0,this}),d("compare",function(a,b){b=b||Object.compare;var c,d,e,f,h;if(this===a)return 0;if(!a||!Array.isArray(a))return g.prototype.compare.call(this,a,b);for(d=Math.min(this.length,a.length),c=0;c<d;c++)if(c in this){if(!(c in a))return-1;if(e=this[c],f=a[c],h=b(e,f))return h}else if(c in a)return 1;return this.length-a.length}),d("equals",function(a,b){b=b||Object.equals;var c,d,e=0,f=this.length;if(this===a)return!0;if(!a||!Array.isArray(a))return g.prototype.equals.call(this,a);if(f!==a.length)return!1;for(;e<f;++e)if(e in this){if(!(e in a))return!1;if(c=this[e],d=a[e],!b(c,d))return!1}else if(e in a)return!1;return!0}),d("clone",function(a,b){if(null==a)a=1/0;else if(0===a)return this;if(b=b||new h,b.has(this))return b.get(this);var c=new Array(this.length);b.set(this,c);for(var d in this)c[d]=Object.clone(this[d],a-1,b);return c}),d("iterate",function(a,b){return new e(this,a,b)}),d("Iterator",e),e.prototype.next=function(){if(this.start===(null==this.end?this.array.length:this.end))throw StopIteration;return this.array[this.start++]}},{"./generic-collection":8,"./generic-order":10,"./shim-function":19,"weak-map":16}],19:[function(a,b,c){b.exports=Function,Function.noop=function(){},Function.identity=function(a){return a},Function.by=function(a,b){b=b||Object.compare,a=a||Function.identity;var c=function(c,d){return b(a(c),a(d))};return c.compare=b,c.by=a,c},Function.get=function(a){return function(b){return Object.get(b,a)}}},{}],20:[function(a,b,c){"use strict";var d=a("weak-map");b.exports=Object,Object.empty=Object.freeze(Object.create(null)),Object.isObject=function(a){return Object(a)===a},Object.getValueOf=function(a){return a&&"function"==typeof a.valueOf&&(a=a.valueOf()),a};var e=new d;Object.hash=function(a){return a&&"function"==typeof a.hash?""+a.hash():Object(a)===a?(e.has(a)||e.set(a,Math.random().toString(36).slice(2)),e.get(a)):""+a};var f=Object.prototype.hasOwnProperty;Object.owns=function(a,b){return f.call(a,b)},Object.has=function(a,b){if("object"!=typeof a)throw new Error("Object.has can't accept non-object: "+typeof a);if(a&&"function"==typeof a.has)return a.has(b);if("string"==typeof b)return b in a&&a[b]!==Object.prototype[b];throw new Error("Key must be a string for Object.has on plain objects")},Object.get=function(a,b,c){if("object"!=typeof a)throw new Error("Object.get can't accept non-object: "+typeof a);return a&&"function"==typeof a.get?a.get(b,c):Object.has(a,b)?a[b]:c},Object.set=function(a,b,c){a&&"function"==typeof a.set?a.set(b,c):a[b]=c},Object.addEach=function(a,b){if(b)if("function"!=typeof b.forEach||b.hasOwnProperty("forEach"))if("number"==typeof b.length)for(var c=0;c<b.length;c++)a[c]=b[c];else Object.keys(b).forEach(function(c){a[c]=b[c]});else b.isMap===!0?b.forEach(function(b,c){a[c]=b}):b.forEach(function(b){a[b[0]]=b[1]});else;return a},Object.forEach=function(a,b,c){Object.keys(a).forEach(function(d){b.call(c,a[d],d,a)})},Object.map=function(a,b,c){return Object.keys(a).map(function(d){return b.call(c,a[d],d,a)})},Object.values=function(a){return Object.map(a,Function.identity)},Object.concat=function(){for(var a={},b=0;b<arguments.length;b++)Object.addEach(a,arguments[b]);return a},Object.from=Object.concat,Object.is=function(a,b){return a===b?0!==a||1/a==1/b:a!==a&&b!==b},Object.equals=function(a,b,c,e){if(c=c||Object.equals,a=Object.getValueOf(a),b=Object.getValueOf(b),a===b)return!0;if(Object.isObject(a)){if(e=e||new d,e.has(a))return!0;e.set(a,!0)}if(Object.isObject(a)&&"function"==typeof a.equals)return a.equals(b,c,e);if(Object.isObject(b)&&"function"==typeof b.equals)return b.equals(a,c,e);if(Object.isObject(a)&&Object.isObject(b)&&Object.getPrototypeOf(a)===Object.prototype&&Object.getPrototypeOf(b)===Object.prototype){for(var f in a)if(!c(a[f],b[f],c,e))return!1;for(var f in b)if(!(f in a&&c(b[f],a[f],c,e)))return!1;return!0}return a!==a&&b!==b||(!a||!b)&&a===b},Object.compare=function(a,b){if(a=Object.getValueOf(a),b=Object.getValueOf(b),a===b)return 0;var c=typeof a,d=typeof b;return"number"===c&&"number"===d?a-b:"string"===c&&"string"===d?a<b?-(1/0):1/0:a&&"function"==typeof a.compare?a.compare(b):b&&"function"==typeof b.compare?-b.compare(a):0},Object.clone=function(a,b,c){if(a=Object.getValueOf(a),c=c||new d,void 0===b)b=1/0;else if(0===b)return a;if(Object.isObject(a)){if(!c.has(a))if(a&&"function"==typeof a.clone)c.set(a,a.clone(b,c));else{var e=Object.getPrototypeOf(a);if(null!==e&&e!==Object.prototype)throw new Error("Can't clone "+a);var f=Object.create(e);c.set(a,f);for(var g in a)f[g]=Object.clone(a[g],b-1,c)}return c.get(a)}return a},Object.clear=function(a){if(a&&"function"==typeof a.clear)a.clear();else for(var b=Object.keys(a),c=b.length;c;)c--,delete a[b[c]];return a}},{"weak-map":16}],21:[function(a,b,c){if(!RegExp.escape){RegExp.escape=function(a){return a.replace(/[-[\]{}()*+?.\\^$|,#\s]/g,"\\$&")}}},{}],22:[function(a,b,c){a("./shim-array"),a("./shim-object"),a("./shim-function"),a("./shim-regexp")},{"./shim-array":18,"./shim-function":19,"./shim-object":20,"./shim-regexp":21}],23:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);this.contentEquals=b||Object.equals,this.contentCompare=c||Object.compare,this.getDefault=e||Function.noop,this.root=null,this.length=0,this.addEach(a)}function e(a){this.value=a,this.left=null,this.right=null,this.length=1}function f(a,b,c){if(this.set=a,this.prev=null,this.end=c,b){var d=this.set.findLeastGreaterThanOrEqual(b);d&&(this.set.splay(d.value),this.prev=d.getPrevious())}}b.exports=d;var g=(a("./shim"),a("./generic-collection")),h=a("./generic-set"),i=a("./listen/property-changes"),j=a("./listen/range-changes"),k=a("./tree-log");d.SortedSet=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.isSorted=!0,d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentCompare,this.getDefault)},d.prototype.has=function(a,b){if(b)throw new Error("SortedSet#has does not support second argument: equals");return!!this.root&&(this.splay(a),this.contentEquals(a,this.root.value))},d.prototype.get=function(a,b){if(b)throw new Error("SortedSet#get does not support second argument: equals");return this.root&&(this.splay(a),this.contentEquals(a,this.root.value))?this.root.value:this.getDefault(a)},d.prototype.add=function(a){var b=new this.Node(a);if(!this.root)return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],0),this.root=b,this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],0),!0;if(this.splay(a),!this.contentEquals(a,this.root.value)){var c=this.contentCompare(a,this.root.value);if(0===c)throw new Error("SortedSet cannot contain incomparable but inequal values: "+a+" and "+this.root.value);return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],this.root.index),c<0?(b.right=this.root,b.left=this.root.left,this.root.left=null,this.root.touch()):(b.left=this.root,b.right=this.root.right,this.root.right=null,this.root.touch()),b.touch(),this.root=b,this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],this.root.index),!0}return!1},d.prototype.delete=function(a,b){if(b)throw new Error("SortedSet#delete does not support second argument: equals");if(this.root&&(this.splay(a),this.contentEquals(a,this.root.value))){var c=this.root.index;if(this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([],[a],c),this.root.left){var d=this.root.right;this.root=this.root.left,this.splay(a),this.root.right=d}else this.root=this.root.right;return this.length--,this.root&&this.root.touch(),this.dispatchesRangeChanges&&this.dispatchRangeChange([],[a],c),!0}return!1},d.prototype.indexOf=function(a,b){if(b)throw new Error("SortedSet#indexOf does not support second argument: startIndex");return this.root&&(this.splay(a),this.contentEquals(a,this.root.value))?this.root.index:-1},d.prototype.find=function(a,b,c){if(b)throw new Error("SortedSet#find does not support second argument: equals");if(c)throw new Error("SortedSet#find does not support third argument: index");if(this.root&&(this.splay(a),this.contentEquals(a,this.root.value)))return this.root},d.prototype.findGreatest=function(a){if(this.root){for(a=a||this.root;a.right;)a=a.right;return a}},d.prototype.findLeast=function(a){if(this.root){for(a=a||this.root;a.left;)a=a.left;return a}},d.prototype.findGreatestLessThanOrEqual=function(a){if(this.root)return this.splay(a),this.contentCompare(this.root.value,a)>0?this.root.getPrevious():this.root},d.prototype.findGreatestLessThan=function(a){if(this.root)return this.splay(a),this.contentCompare(this.root.value,a)>=0?this.root.getPrevious():this.root},d.prototype.findLeastGreaterThanOrEqual=function(a){if(this.root)return this.splay(a),this.contentCompare(this.root.value,a)>=0?this.root:this.root.getNext()},d.prototype.findLeastGreaterThan=function(a){if(this.root)return this.splay(a),this.contentCompare(this.root.value,a)<=0?this.root.getNext():this.root},d.prototype.pop=function(){if(this.root){var a=this.findGreatest();return this.delete(a.value),a.value}},d.prototype.shift=function(){if(this.root){var a=this.findLeast()
+;return this.delete(a.value),a.value}},d.prototype.push=function(){this.addEach(arguments)},d.prototype.unshift=function(){this.addEach(arguments)},d.prototype.slice=function(a,b){a=a||0,b=b||this.length,a<0&&(a+=this.length),b<0&&(b+=this.length);var c=[];if(this.root)for(this.splayIndex(a);this.root.index<b&&(c.push(this.root.value),this.root.right);)this.splay(this.root.getNext().value);return c},d.prototype.splice=function(a,b){return this.swap(a,b,Array.prototype.slice.call(arguments,2))},d.prototype.swap=function(a,b,c){if(void 0===a&&void 0===b)return[];a=a||0,a<0&&(a+=this.length),void 0===b&&(b=1/0);var d=[];if(this.root){this.splayIndex(a);for(var e=0;e<b;e++){d.push(this.root.value);var f=this.root.getNext();if(this.delete(this.root.value),!f)break;this.splay(f.value)}}return this.addEach(c),d},d.prototype.splay=function(a){var b,c,d,f,g,h;if(this.root){for(b=c=d=new this.Node,h=new this.Node,g=this.root;;){var i=this.contentCompare(a,g.value);if(i<0){if(!g.left)break;if(this.contentCompare(a,g.left.value)<0&&(f=g.left,g.left=f.right,g.touch(),f.right=g,f.touch(),g=f,!g.left))break;f=new e,f.right=g,f.left=h.left,h.left=f,d.left=g,d.touch(),d=g,g=g.left}else{if(!(i>0))break;if(!g.right)break;if(this.contentCompare(a,g.right.value)>0&&(f=g.right,g.right=f.left,g.touch(),f.left=g,f.touch(),g=f,!g.right))break;f=new e,f.left=g,f.right=h.right,h.right=f,c.right=g,c.touch(),c=g,g=g.right}}for(c.right=g.left,c.touch(),d.left=g.right,d.touch(),g.left=b.right,g.right=b.left;h.left;)h.left.right.touch(),h.left=h.left.left;for(;h.right;)h.right.left.touch(),h.right=h.right.right;g.touch(),this.root=g}},d.prototype.splayIndex=function(a){if(this.root){for(var b=this.root,c=this.root.index;c!==a;)if(c>a&&b.left)b=b.left,c-=1+(b.right?b.right.length:0);else{if(!(c<a&&b.right))break;b=b.right,c+=1+(b.left?b.left.length:0)}return this.splay(b.value),this.root.index===a}return!1},d.prototype.reduce=function(a,b,c){return this.root&&(b=this.root.reduce(a,b,0,c,this)),b},d.prototype.reduceRight=function(a,b,c){return this.root&&(b=this.root.reduceRight(a,b,this.length-1,c,this)),b},d.prototype.min=function(a){var b=this.findLeast(a);if(b)return b.value},d.prototype.max=function(a){var b=this.findGreatest(a);if(b)return b.value},d.prototype.one=function(){return this.min()},d.prototype.clear=function(){var a;this.dispatchesRangeChanges&&(a=this.toArray(),this.dispatchBeforeRangeChange([],a,0)),this.root=null,this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange([],a,0)},d.prototype.iterate=function(a,b){return new this.Iterator(this,a,b)},d.prototype.Iterator=f,d.prototype.summary=function(){return this.root?this.root.summary():"()"},d.prototype.log=function(a,b,c,d){a=a||k.unicodeRound,b=b||this.logNode,c||(c=console.log,d=console),c=c.bind(d),this.root&&this.root.log(a,b,c,c)},d.prototype.logNode=function(a,b,c){b(" "+a.value)},d.logCharsets=k,d.prototype.Node=e,e.prototype.reduce=function(a,b,c,d,e,f){if(f=f||0,this.left){var g=this.left.length;b=this.left.reduce(a,b,c,d,e,f+1),c+=g}return b=a.call(d,b,this.value,c,e,this,f),c+=1,this.right&&(b=this.right.reduce(a,b,c,d,e,f+1)),b},e.prototype.reduceRight=function(a,b,c,d,e,f){return f=f||0,this.right&&(b=this.right.reduce(a,b,c,d,e,f+1),c-=this.right.length),b=a.call(d,b,this.value,this.value,e,this,f),c-=1,this.left&&(b=this.left.reduce(a,b,c,d,e,f+1)),b},e.prototype.touch=function(){this.length=1+(this.left?this.left.length:0)+(this.right?this.right.length:0),this.index=this.left?this.left.length:0},e.prototype.checkIntegrity=function(){var a=1;if(a+=this.left?this.left.checkIntegrity():0,a+=this.right?this.right.checkIntegrity():0,this.length!==a)throw new Error("Integrity check failed: "+this.summary());return a},e.prototype.getNext=function(){var a=this;if(a.right){for(a=a.right;a.left;)a=a.left;return a}},e.prototype.getPrevious=function(){var a=this;if(a.left){for(a=a.left;a.right;)a=a.right;return a}},e.prototype.summary=function(){var a=this.value||"-";return a+=" <"+this.length,this.left||this.right?"("+a+" "+(this.left?this.left.summary():"()")+", "+(this.right?this.right.summary():"()")+")":"("+a+")"},e.prototype.log=function(a,b,c,d){var e,f=this;e=this.left&&this.right?a.intersection:this.left?a.branchUp:this.right?a.branchDown:a.through;var g;this.left&&this.left.log(a,b,function(b){g?d(a.strafe+" "+b):(g=!0,d(a.fromBelow+a.through+b))},function(a){d("  "+a)});var h;b(this,function(b){h?c((f.right?a.strafe:" ")+b):(h=!0,c(e+b))},function(b){d((f.left?a.strafe:" ")+b)});var i;this.right&&this.right.log(a,b,function(b){i?c("  "+b):(i=!0,c(a.fromAbove+a.through+b))},function(b){c(a.strafe+" "+b)})},f.prototype.next=function(){var a;if(!(a=this.prev?this.set.findLeastGreaterThan(this.prev.value):this.set.findLeast()))throw StopIteration;if(void 0!==this.end&&this.set.contentCompare(a.value,this.end)>=0)throw StopIteration;return this.prev=a,a.value}},{"./generic-collection":8,"./generic-set":11,"./listen/property-changes":14,"./listen/range-changes":15,"./shim":22,"./tree-log":24}],24:[function(a,b,c){"use strict";function d(){}b.exports=d,d.ascii={intersection:"+",through:"-",branchUp:"+",branchDown:"+",fromBelow:".",fromAbove:"'",fromBoth:"+",strafe:"|"},d.unicodeRound={intersection:"╋",through:"━",branchUp:"┻",branchDown:"┳",fromBelow:"╭",fromAbove:"╰",fromBoth:"┣",strafe:"┃"},d.unicodeSharp={intersection:"╋",through:"━",branchUp:"┻",branchDown:"┳",fromBelow:"┏",fromAbove:"┗",fromBoth:"┣",strafe:"┃"}},{}],25:[function(a,b,c){!function(){function a(a){return a&&(a.ownerDocument||a.document||a).documentElement}function c(a){return a&&(a.ownerDocument&&a.ownerDocument.defaultView||a.document&&a||a.defaultView)}function d(a,b){return a<b?-1:a>b?1:a>=b?0:NaN}function e(a){return null===a?NaN:+a}function f(a){return!isNaN(a)}function g(a){return{left:function(b,c,d,e){for(arguments.length<3&&(d=0),arguments.length<4&&(e=b.length);d<e;){var f=d+e>>>1;a(b[f],c)<0?d=f+1:e=f}return d},right:function(b,c,d,e){for(arguments.length<3&&(d=0),arguments.length<4&&(e=b.length);d<e;){var f=d+e>>>1;a(b[f],c)>0?e=f:d=f+1}return d}}}function h(a){return a.length}function i(a){for(var b=1;a*b%1;)b*=10;return b}function j(a,b){for(var c in b)Object.defineProperty(a.prototype,c,{value:b[c],enumerable:!1})}function k(){this._=Object.create(null)}function l(a){return(a+="")===tg||a[0]===ug?ug+a:a}function m(a){return(a+="")[0]===ug?a.slice(1):a}function n(a){return l(a)in this._}function o(a){return(a=l(a))in this._&&delete this._[a]}function p(){var a=[];for(var b in this._)a.push(m(b));return a}function q(){var a=0;for(var b in this._)++a;return a}function r(){for(var a in this._)return!1;return!0}function s(){this._=Object.create(null)}function t(a){return a}function u(a,b,c){return function(){var d=c.apply(b,arguments);return d===b?a:d}}function v(a,b){if(b in a)return b;b=b.charAt(0).toUpperCase()+b.slice(1);for(var c=0,d=vg.length;c<d;++c){var e=vg[c]+b;if(e in a)return e}}function w(){}function x(){}function y(a){function b(){for(var b,d=c,e=-1,f=d.length;++e<f;)(b=d[e].on)&&b.apply(this,arguments);return a}var c=[],d=new k;return b.on=function(b,e){var f,g=d.get(b);return arguments.length<2?g&&g.on:(g&&(g.on=null,c=c.slice(0,f=c.indexOf(g)).concat(c.slice(f+1)),d.remove(b)),e&&c.push(d.set(b,{on:e})),a)},b}function z(){ig.event.preventDefault()}function A(){for(var a,b=ig.event;a=b.sourceEvent;)b=a;return b}function B(a){for(var b=new x,c=0,d=arguments.length;++c<d;)b[arguments[c]]=y(b);return b.of=function(c,d){return function(e){try{var f=e.sourceEvent=ig.event;e.target=a,ig.event=e,b[e.type].apply(c,d)}finally{ig.event=f}}},b}function C(a){return xg(a,Bg),a}function D(a){return"function"==typeof a?a:function(){return yg(a,this)}}function E(a){return"function"==typeof a?a:function(){return zg(a,this)}}function F(a,b){function c(){this.removeAttribute(a)}function d(){this.removeAttributeNS(a.space,a.local)}function e(){this.setAttribute(a,b)}function f(){this.setAttributeNS(a.space,a.local,b)}function g(){var c=b.apply(this,arguments);null==c?this.removeAttribute(a):this.setAttribute(a,c)}function h(){var c=b.apply(this,arguments);null==c?this.removeAttributeNS(a.space,a.local):this.setAttributeNS(a.space,a.local,c)}return a=ig.ns.qualify(a),null==b?a.local?d:c:"function"==typeof b?a.local?h:g:a.local?f:e}function G(a){return a.trim().replace(/\s+/g," ")}function H(a){return new RegExp("(?:^|\\s+)"+ig.requote(a)+"(?:\\s+|$)","g")}function I(a){return(a+"").trim().split(/^|\s+/)}function J(a,b){function c(){for(var c=-1;++c<e;)a[c](this,b)}function d(){for(var c=-1,d=b.apply(this,arguments);++c<e;)a[c](this,d)}a=I(a).map(K);var e=a.length;return"function"==typeof b?d:c}function K(a){var b=H(a);return function(c,d){if(e=c.classList)return d?e.add(a):e.remove(a);var e=c.getAttribute("class")||"";d?(b.lastIndex=0,b.test(e)||c.setAttribute("class",G(e+" "+a))):c.setAttribute("class",G(e.replace(b," ")))}}function L(a,b,c){function d(){this.style.removeProperty(a)}function e(){this.style.setProperty(a,b,c)}function f(){var d=b.apply(this,arguments);null==d?this.style.removeProperty(a):this.style.setProperty(a,d,c)}return null==b?d:"function"==typeof b?f:e}function M(a,b){function c(){delete this[a]}function d(){this[a]=b}function e(){var c=b.apply(this,arguments);null==c?delete this[a]:this[a]=c}return null==b?c:"function"==typeof b?e:d}function N(a){function b(){var b=this.ownerDocument,c=this.namespaceURI;return c===Cg&&b.documentElement.namespaceURI===Cg?b.createElement(a):b.createElementNS(c,a)}function c(){return this.ownerDocument.createElementNS(a.space,a.local)}return"function"==typeof a?a:(a=ig.ns.qualify(a)).local?c:b}function O(){var a=this.parentNode;a&&a.removeChild(this)}function P(a){return{__data__:a}}function Q(a){return function(){return Ag(this,a)}}function R(a){return arguments.length||(a=d),function(b,c){return b&&c?a(b.__data__,c.__data__):!b-!c}}function S(a,b){for(var c=0,d=a.length;c<d;c++)for(var e,f=a[c],g=0,h=f.length;g<h;g++)(e=f[g])&&b(e,g,c);return a}function T(a){return xg(a,Eg),a}function U(a){var b,c;return function(d,e,f){var g,h=a[f].update,i=h.length;for(f!=c&&(c=f,b=0),e>=b&&(b=e+1);!(g=h[b])&&++b<i;);return g}}function V(a,b,c){function d(){var b=this[g];b&&(this.removeEventListener(a,b,b.$),delete this[g])}function e(){var e=i(b,kg(arguments));d.call(this),this.addEventListener(a,this[g]=e,e.$=c),e._=b}function f(){var b,c=new RegExp("^__on([^.]+)"+ig.requote(a)+"$");for(var d in this)if(b=d.match(c)){var e=this[d];this.removeEventListener(b[1],e,e.$),delete this[d]}}var g="__on"+a,h=a.indexOf("."),i=W;h>0&&(a=a.slice(0,h));var j=Fg.get(a);return j&&(a=j,i=X),h?b?e:d:b?w:f}function W(a,b){return function(c){var d=ig.event;ig.event=c,b[0]=this.__data__;try{a.apply(this,b)}finally{ig.event=d}}}function X(a,b){var c=W(a,b);return function(a){var b=this,d=a.relatedTarget;d&&(d===b||8&d.compareDocumentPosition(b))||c.call(b,a)}}function Y(b){var d=".dragsuppress-"+ ++Hg,e="click"+d,f=ig.select(c(b)).on("touchmove"+d,z).on("dragstart"+d,z).on("selectstart"+d,z);if(null==Gg&&(Gg=!("onselectstart"in b)&&v(b.style,"userSelect")),Gg){var g=a(b).style,h=g[Gg];g[Gg]="none"}return function(a){if(f.on(d,null),Gg&&(g[Gg]=h),a){var b=function(){f.on(e,null)};f.on(e,function(){z(),b()},!0),setTimeout(b,0)}}}function Z(a,b){b.changedTouches&&(b=b.changedTouches[0]);var d=a.ownerSVGElement||a;if(d.createSVGPoint){var e=d.createSVGPoint();if(Ig<0){var f=c(a);if(f.scrollX||f.scrollY){d=ig.select("body").append("svg").style({position:"absolute",top:0,left:0,margin:0,padding:0,border:"none"},"important");var g=d[0][0].getScreenCTM();Ig=!(g.f||g.e),d.remove()}}return Ig?(e.x=b.pageX,e.y=b.pageY):(e.x=b.clientX,e.y=b.clientY),e=e.matrixTransform(a.getScreenCTM().inverse()),[e.x,e.y]}var h=a.getBoundingClientRect();return[b.clientX-h.left-a.clientLeft,b.clientY-h.top-a.clientTop]}function $(){return ig.event.changedTouches[0].identifier}function _(a){return a>0?1:a<0?-1:0}function aa(a,b,c){return(b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0])}function ba(a){return a>1?0:a<-1?Lg:Math.acos(a)}function ca(a){return a>1?Og:a<-1?-Og:Math.asin(a)}function da(a){return((a=Math.exp(a))-1/a)/2}function ea(a){return((a=Math.exp(a))+1/a)/2}function fa(a){return((a=Math.exp(2*a))-1)/(a+1)}function ga(a){return(a=Math.sin(a/2))*a}function ha(){}function ia(a,b,c){return this instanceof ia?(this.h=+a,this.s=+b,void(this.l=+c)):arguments.length<2?a instanceof ia?new ia(a.h,a.s,a.l):wa(""+a,xa,ia):new ia(a,b,c)}function ja(a,b,c){function d(a){return a>360?a-=360:a<0&&(a+=360),a<60?f+(g-f)*a/60:a<180?g:a<240?f+(g-f)*(240-a)/60:f}function e(a){return Math.round(255*d(a))}var f,g;return a=isNaN(a)?0:(a%=360)<0?a+360:a,b=isNaN(b)?0:b<0?0:b>1?1:b,c=c<0?0:c>1?1:c,g=c<=.5?c*(1+b):c+b-c*b,f=2*c-g,new sa(e(a+120),e(a),e(a-120))}function ka(a,b,c){return this instanceof ka?(this.h=+a,this.c=+b,void(this.l=+c)):arguments.length<2?a instanceof ka?new ka(a.h,a.c,a.l):a instanceof ma?oa(a.l,a.a,a.b):oa((a=ya((a=ig.rgb(a)).r,a.g,a.b)).l,a.a,a.b):new ka(a,b,c)}function la(a,b,c){return isNaN(a)&&(a=0),isNaN(b)&&(b=0),new ma(c,Math.cos(a*=Pg)*b,Math.sin(a)*b)}function ma(a,b,c){return this instanceof ma?(this.l=+a,this.a=+b,void(this.b=+c)):arguments.length<2?a instanceof ma?new ma(a.l,a.a,a.b):a instanceof ka?la(a.h,a.c,a.l):ya((a=sa(a)).r,a.g,a.b):new ma(a,b,c)}function na(a,b,c){var d=(a+16)/116,e=d+b/500,f=d-c/200;return e=pa(e)*Yg,d=pa(d)*Zg,f=pa(f)*$g,new sa(ra(3.2404542*e-1.5371385*d-.4985314*f),ra(-.969266*e+1.8760108*d+.041556*f),ra(.0556434*e-.2040259*d+1.0572252*f))}function oa(a,b,c){return a>0?new ka(Math.atan2(c,b)*Qg,Math.sqrt(b*b+c*c),a):new ka(NaN,NaN,a)}function pa(a){return a>.206893034?a*a*a:(a-4/29)/7.787037}function qa(a){return a>.008856?Math.pow(a,1/3):7.787037*a+4/29}function ra(a){return Math.round(255*(a<=.00304?12.92*a:1.055*Math.pow(a,1/2.4)-.055))}function sa(a,b,c){return this instanceof sa?(this.r=~~a,this.g=~~b,void(this.b=~~c)):arguments.length<2?a instanceof sa?new sa(a.r,a.g,a.b):wa(""+a,sa,ja):new sa(a,b,c)}function ta(a){return new sa(a>>16,a>>8&255,255&a)}function ua(a){return ta(a)+""}function va(a){return a<16?"0"+Math.max(0,a).toString(16):Math.min(255,a).toString(16)}function wa(a,b,c){var d,e,f,g=0,h=0,i=0;if(d=/([a-z]+)\((.*)\)/.exec(a=a.toLowerCase()))switch(e=d[2].split(","),d[1]){case"hsl":return c(parseFloat(e[0]),parseFloat(e[1])/100,parseFloat(e[2])/100);case"rgb":return b(Aa(e[0]),Aa(e[1]),Aa(e[2]))}return(f=bh.get(a))?b(f.r,f.g,f.b):(null==a||"#"!==a.charAt(0)||isNaN(f=parseInt(a.slice(1),16))||(4===a.length?(g=(3840&f)>>4,g|=g>>4,h=240&f,h|=h>>4,i=15&f,i|=i<<4):7===a.length&&(g=(16711680&f)>>16,h=(65280&f)>>8,i=255&f)),b(g,h,i))}function xa(a,b,c){var d,e,f=Math.min(a/=255,b/=255,c/=255),g=Math.max(a,b,c),h=g-f,i=(g+f)/2;return h?(e=i<.5?h/(g+f):h/(2-g-f),d=a==g?(b-c)/h+(b<c?6:0):b==g?(c-a)/h+2:(a-b)/h+4,d*=60):(d=NaN,e=i>0&&i<1?0:d),new ia(d,e,i)}function ya(a,b,c){a=za(a),b=za(b),c=za(c);var d=qa((.4124564*a+.3575761*b+.1804375*c)/Yg),e=qa((.2126729*a+.7151522*b+.072175*c)/Zg);return ma(116*e-16,500*(d-e),200*(e-qa((.0193339*a+.119192*b+.9503041*c)/$g)))}function za(a){return(a/=255)<=.04045?a/12.92:Math.pow((a+.055)/1.055,2.4)}function Aa(a){var b=parseFloat(a);return"%"===a.charAt(a.length-1)?Math.round(2.55*b):b}function Ba(a){return"function"==typeof a?a:function(){return a}}function Ca(a){return function(b,c,d){return 2===arguments.length&&"function"==typeof c&&(d=c,c=null),Da(b,c,a,d)}}function Da(a,b,c,d){function e(){var a,b=i.status;if(!b&&Fa(i)||b>=200&&b<300||304===b){try{a=c.call(f,i)}catch(a){return void g.error.call(f,a)}g.load.call(f,a)}else g.error.call(f,i)}var f={},g=ig.dispatch("beforesend","progress","load","error"),h={},i=new XMLHttpRequest,j=null;return!this.XDomainRequest||"withCredentials"in i||!/^(http(s)?:)?\/\//.test(a)||(i=new XDomainRequest),"onload"in i?i.onload=i.onerror=e:i.onreadystatechange=function(){i.readyState>3&&e()},i.onprogress=function(a){var b=ig.event;ig.event=a;try{g.progress.call(f,i)}finally{ig.event=b}},f.header=function(a,b){return a=(a+"").toLowerCase(),arguments.length<2?h[a]:(null==b?delete h[a]:h[a]=b+"",f)},f.mimeType=function(a){return arguments.length?(b=null==a?null:a+"",f):b},f.responseType=function(a){return arguments.length?(j=a,f):j},f.response=function(a){return c=a,f},["get","post"].forEach(function(a){f[a]=function(){return f.send.apply(f,[a].concat(kg(arguments)))}}),f.send=function(c,d,e){if(2===arguments.length&&"function"==typeof d&&(e=d,d=null),i.open(c,a,!0),null==b||"accept"in h||(h.accept=b+",*/*"),i.setRequestHeader)for(var k in h)i.setRequestHeader(k,h[k]);return null!=b&&i.overrideMimeType&&i.overrideMimeType(b),null!=j&&(i.responseType=j),null!=e&&f.on("error",e).on("load",function(a){e(null,a)}),g.beforesend.call(f,i),i.send(null==d?null:d),f},f.abort=function(){return i.abort(),f},ig.rebind(f,g,"on"),null==d?f:f.get(Ea(d))}function Ea(a){return 1===a.length?function(b,c){a(null==b?c:null)}:a}function Fa(a){var b=a.responseType;return b&&"text"!==b?a.response:a.responseText}function Ga(a,b,c){var d=arguments.length;d<2&&(b=0),d<3&&(c=Date.now());var e=c+b,f={c:a,t:e,n:null};return dh?dh.n=f:ch=f,dh=f,eh||(fh=clearTimeout(fh),eh=1,gh(Ha)),f}function Ha(){var a=Ia(),b=Ja()-a;b>24?(isFinite(b)&&(clearTimeout(fh),fh=setTimeout(Ha,b)),eh=0):(eh=1,gh(Ha))}function Ia(){for(var a=Date.now(),b=ch;b;)a>=b.t&&b.c(a-b.t)&&(b.c=null),b=b.n;return a}function Ja(){for(var a,b=ch,c=1/0;b;)b.c?(b.t<c&&(c=b.t),b=(a=b).n):b=a?a.n=b.n:ch=b.n;return dh=a,c}function Ka(a,b){return b-(a?Math.ceil(Math.log(a)/Math.LN10):1)}function La(a,b){var c=Math.pow(10,3*sg(8-b));return{scale:b>8?function(a){return a/c}:function(a){return a*c},symbol:a}}function Ma(a){var b=a.decimal,c=a.thousands,d=a.grouping,e=a.currency,f=d&&c?function(a,b){for(var e=a.length,f=[],g=0,h=d[0],i=0;e>0&&h>0&&(i+h+1>b&&(h=Math.max(1,b-i)),f.push(a.substring(e-=h,e+h)),!((i+=h+1)>b));)h=d[g=(g+1)%d.length];return f.reverse().join(c)}:t;return function(a){var c=ih.exec(a),d=c[1]||" ",g=c[2]||">",h=c[3]||"-",i=c[4]||"",j=c[5],k=+c[6],l=c[7],m=c[8],n=c[9],o=1,p="",q="",r=!1,s=!0;switch(m&&(m=+m.substring(1)),(j||"0"===d&&"="===g)&&(j=d="0",g="="),n){case"n":l=!0,n="g";break;case"%":o=100,q="%",n="f";break;case"p":o=100,q="%",n="r";break;case"b":case"o":case"x":case"X":"#"===i&&(p="0"+n.toLowerCase());case"c":s=!1;case"d":r=!0,m=0;break;case"s":o=-1,n="r"}"$"===i&&(p=e[0],q=e[1]),"r"!=n||m||(n="g"),null!=m&&("g"==n?m=Math.max(1,Math.min(21,m)):"e"!=n&&"f"!=n||(m=Math.max(0,Math.min(20,m)))),n=jh.get(n)||Na;var t=j&&l;return function(a){var c=q;if(r&&a%1)return"";var e=a<0||0===a&&1/a<0?(a=-a,"-"):"-"===h?"":h;if(o<0){var i=ig.formatPrefix(a,m);a=i.scale(a),c=i.symbol+q}else a*=o;a=n(a,m);var u,v,w=a.lastIndexOf(".");if(w<0){var x=s?a.lastIndexOf("e"):-1;x<0?(u=a,v=""):(u=a.substring(0,x),v=a.substring(x))}else u=a.substring(0,w),v=b+a.substring(w+1);!j&&l&&(u=f(u,1/0));var y=p.length+u.length+v.length+(t?0:e.length),z=y<k?new Array(y=k-y+1).join(d):"";return t&&(u=f(z+u,z.length?k-v.length:1/0)),e+=p,a=u+v,("<"===g?e+a+z:">"===g?z+e+a:"^"===g?z.substring(0,y>>=1)+e+a+z.substring(y):e+(t?a:z+a))+c}}}function Na(a){return a+""}function Oa(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arguments):arguments[0])}function Pa(a,b,c){function d(b){var c=a(b),d=f(c,1);return b-c<d-b?c:d}function e(c){return b(c=a(new lh(c-1)),1),c}function f(a,c){return b(a=new lh(+a),c),a}function g(a,d,f){var g=e(a),h=[];if(f>1)for(;g<d;)c(g)%f||h.push(new Date(+g)),b(g,1);else for(;g<d;)h.push(new Date(+g)),b(g,1);return h}function h(a,b,c){try{lh=Oa;var d=new Oa;return d._=a,g(d,b,c)}finally{lh=Date}}a.floor=a,a.round=d,a.ceil=e,a.offset=f,a.range=g;var i=a.utc=Qa(a);return i.floor=i,i.round=Qa(d),i.ceil=Qa(e),i.offset=Qa(f),i.range=h,a}function Qa(a){return function(b,c){try{lh=Oa;var d=new Oa;return d._=b,a(d,c)._}finally{lh=Date}}}function Ra(a){function b(a){function b(b){for(var c,e,f,g=[],h=-1,i=0;++h<d;)37===a.charCodeAt(h)&&(g.push(a.slice(i,h)),null!=(e=nh[c=a.charAt(++h)])&&(c=a.charAt(++h)),(f=C[c])&&(c=f(b,null==e?"e"===c?" ":"0":e)),g.push(c),i=h+1);return g.push(a.slice(i,h)),g.join("")}var d=a.length;return b.parse=function(b){var d={y:1900,m:0,d:1,H:0,M:0,S:0,L:0,Z:null};if(c(d,a,b,0)!=b.length)return null;"p"in d&&(d.H=d.H%12+12*d.p);var e=null!=d.Z&&lh!==Oa,f=new(e?Oa:lh);return"j"in d?f.setFullYear(d.y,0,d.j):"W"in d||"U"in d?("w"in d||(d.w="W"in d?1:0),f.setFullYear(d.y,0,1),f.setFullYear(d.y,0,"W"in d?(d.w+6)%7+7*d.W-(f.getDay()+5)%7:d.w+7*d.U-(f.getDay()+6)%7)):f.setFullYear(d.y,d.m,d.d),f.setHours(d.H+(d.Z/100|0),d.M+d.Z%100,d.S,d.L),e?f._:f},b.toString=function(){return a},b}function c(a,b,c,d){for(var e,f,g,h=0,i=b.length,j=c.length;h<i;){if(d>=j)return-1;if(37===(e=b.charCodeAt(h++))){if(g=b.charAt(h++),!(f=D[g in nh?b.charAt(h++):g])||(d=f(a,c,d))<0)return-1}else if(e!=c.charCodeAt(d++))return-1}return d}function d(a,b,c){w.lastIndex=0;var d=w.exec(b.slice(c));return d?(a.w=x.get(d[0].toLowerCase()),c+d[0].length):-1}function e(a,b,c){u.lastIndex=0;var d=u.exec(b.slice(c));return d?(a.w=v.get(d[0].toLowerCase()),c+d[0].length):-1}function f(a,b,c){A.lastIndex=0;var d=A.exec(b.slice(c));return d?(a.m=B.get(d[0].toLowerCase()),c+d[0].length):-1}function g(a,b,c){y.lastIndex=0;var d=y.exec(b.slice(c));return d?(a.m=z.get(d[0].toLowerCase()),c+d[0].length):-1}function h(a,b,d){return c(a,C.c.toString(),b,d)}function i(a,b,d){return c(a,C.x.toString(),b,d)}function j(a,b,d){return c(a,C.X.toString(),b,d)}function k(a,b,c){var d=t.get(b.slice(c,c+=2).toLowerCase());return null==d?-1:(a.p=d,c)}var l=a.dateTime,m=a.date,n=a.time,o=a.periods,p=a.days,q=a.shortDays,r=a.months,s=a.shortMonths;b.utc=function(a){function c(a){try{lh=Oa;var b=new lh;return b._=a,d(b)}finally{lh=Date}}var d=b(a);return c.parse=function(a){try{lh=Oa;var b=d.parse(a);return b&&b._}finally{lh=Date}},c.toString=d.toString,c},b.multi=b.utc.multi=jb;var t=ig.map(),u=Ta(p),v=Ua(p),w=Ta(q),x=Ua(q),y=Ta(r),z=Ua(r),A=Ta(s),B=Ua(s);o.forEach(function(a,b){t.set(a.toLowerCase(),b)});var C={a:function(a){return q[a.getDay()]},A:function(a){return p[a.getDay()]},b:function(a){return s[a.getMonth()]},B:function(a){return r[a.getMonth()]},c:b(l),d:function(a,b){return Sa(a.getDate(),b,2)},e:function(a,b){return Sa(a.getDate(),b,2)},H:function(a,b){return Sa(a.getHours(),b,2)},I:function(a,b){return Sa(a.getHours()%12||12,b,2)},j:function(a,b){return Sa(1+kh.dayOfYear(a),b,3)},L:function(a,b){return Sa(a.getMilliseconds(),b,3)},m:function(a,b){return Sa(a.getMonth()+1,b,2)},M:function(a,b){return Sa(a.getMinutes(),b,2)},p:function(a){return o[+(a.getHours()>=12)]},S:function(a,b){return Sa(a.getSeconds(),b,2)},U:function(a,b){return Sa(kh.sundayOfYear(a),b,2)},w:function(a){return a.getDay()},W:function(a,b){return Sa(kh.mondayOfYear(a),b,2)},x:b(m),X:b(n),y:function(a,b){return Sa(a.getFullYear()%100,b,2)},Y:function(a,b){return Sa(a.getFullYear()%1e4,b,4)},Z:hb,"%":function(){return"%"}},D={a:d,A:e,b:f,B:g,c:h,d:bb,e:bb,H:db,I:db,j:cb,L:gb,m:ab,M:eb,p:k,S:fb,U:Wa,w:Va,W:Xa,x:i,X:j,y:Za,Y:Ya,Z:$a,"%":ib};return b}function Sa(a,b,c){var d=a<0?"-":"",e=(d?-a:a)+"",f=e.length;return d+(f<c?new Array(c-f+1).join(b)+e:e)}function Ta(a){return new RegExp("^(?:"+a.map(ig.requote).join("|")+")","i")}function Ua(a){for(var b=new k,c=-1,d=a.length;++c<d;)b.set(a[c].toLowerCase(),c);return b}function Va(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+1));return d?(a.w=+d[0],c+d[0].length):-1}function Wa(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c));return d?(a.U=+d[0],c+d[0].length):-1}function Xa(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c));return d?(a.W=+d[0],c+d[0].length):-1}function Ya(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+4));return d?(a.y=+d[0],c+d[0].length):-1}function Za(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.y=_a(+d[0]),c+d[0].length):-1}function $a(a,b,c){return/^[+-]\d{4}$/.test(b=b.slice(c,c+5))?(a.Z=-b,c+5):-1}function _a(a){return a+(a>68?1900:2e3)}function ab(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.m=d[0]-1,c+d[0].length):-1}function bb(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.d=+d[0],c+d[0].length):-1}function cb(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+3));return d?(a.j=+d[0],c+d[0].length):-1}function db(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.H=+d[0],c+d[0].length):-1}function eb(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.M=+d[0],c+d[0].length):-1}function fb(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+2));return d?(a.S=+d[0],c+d[0].length):-1}function gb(a,b,c){oh.lastIndex=0;var d=oh.exec(b.slice(c,c+3));return d?(a.L=+d[0],c+d[0].length):-1}function hb(a){var b=a.getTimezoneOffset(),c=b>0?"-":"+",d=sg(b)/60|0,e=sg(b)%60;return c+Sa(d,"0",2)+Sa(e,"0",2)}function ib(a,b,c){ph.lastIndex=0;var d=ph.exec(b.slice(c,c+1));return d?c+d[0].length:-1}function jb(a){for(var b=a.length,c=-1;++c<b;)a[c][0]=this(a[c][0]);return function(b){for(var c=0,d=a[c];!d[1](b);)d=a[++c];return d[0](b)}}function kb(){}function lb(a,b,c){var d=c.s=a+b,e=d-a,f=d-e;c.t=a-f+(b-e)}function mb(a,b){a&&th.hasOwnProperty(a.type)&&th[a.type](a,b)}function nb(a,b,c){var d,e=-1,f=a.length-c;for(b.lineStart();++e<f;)d=a[e],b.point(d[0],d[1],d[2]);b.lineEnd()}function ob(a,b){var c=-1,d=a.length;for(b.polygonStart();++c<d;)nb(a[c],b,1);b.polygonEnd()}function pb(){function a(a,b){a*=Pg,b=b*Pg/2+Lg/4;var c=a-d,g=c>=0?1:-1,h=g*c,i=Math.cos(b),j=Math.sin(b),k=f*j,l=e*i+k*Math.cos(h),m=k*g*Math.sin(h);vh.add(Math.atan2(m,l)),d=a,e=i,f=j}var b,c,d,e,f;wh.point=function(g,h){wh.point=a,d=(b=g)*Pg,e=Math.cos(h=(c=h)*Pg/2+Lg/4),f=Math.sin(h)},wh.lineEnd=function(){a(b,c)}}function qb(a){var b=a[0],c=a[1],d=Math.cos(c);return[d*Math.cos(b),d*Math.sin(b),Math.sin(c)]}function rb(a,b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]}function sb(a,b){return[a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0]]}function tb(a,b){a[0]+=b[0],a[1]+=b[1],a[2]+=b[2]}function ub(a,b){return[a[0]*b,a[1]*b,a[2]*b]}function vb(a){var b=Math.sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);a[0]/=b,a[1]/=b,a[2]/=b}function wb(a){return[Math.atan2(a[1],a[0]),ca(a[2])]}function xb(a,b){return sg(a[0]-b[0])<Jg&&sg(a[1]-b[1])<Jg}function yb(a,b){a*=Pg;var c=Math.cos(b*=Pg);zb(c*Math.cos(a),c*Math.sin(a),Math.sin(b))}function zb(a,b,c){++xh,zh+=(a-zh)/xh,Ah+=(b-Ah)/xh,Bh+=(c-Bh)/xh}function Ab(){function a(a,e){a*=Pg;var f=Math.cos(e*=Pg),g=f*Math.cos(a),h=f*Math.sin(a),i=Math.sin(e),j=Math.atan2(Math.sqrt((j=c*i-d*h)*j+(j=d*g-b*i)*j+(j=b*h-c*g)*j),b*g+c*h+d*i);yh+=j,Ch+=j*(b+(b=g)),Dh+=j*(c+(c=h)),Eh+=j*(d+(d=i)),zb(b,c,d)}var b,c,d;Ih.point=function(e,f){e*=Pg;var g=Math.cos(f*=Pg);b=g*Math.cos(e),c=g*Math.sin(e),d=Math.sin(f),Ih.point=a,zb(b,c,d)}}function Bb(){Ih.point=yb}function Cb(){function a(a,b){a*=Pg;var c=Math.cos(b*=Pg),g=c*Math.cos(a),h=c*Math.sin(a),i=Math.sin(b),j=e*i-f*h,k=f*g-d*i,l=d*h-e*g,m=Math.sqrt(j*j+k*k+l*l),n=d*g+e*h+f*i,o=m&&-ba(n)/m,p=Math.atan2(m,n);Fh+=o*j,Gh+=o*k,Hh+=o*l,yh+=p,Ch+=p*(d+(d=g)),Dh+=p*(e+(e=h)),Eh+=p*(f+(f=i)),zb(d,e,f)}var b,c,d,e,f;Ih.point=function(g,h){b=g,c=h,Ih.point=a,g*=Pg;var i=Math.cos(h*=Pg);d=i*Math.cos(g),e=i*Math.sin(g),f=Math.sin(h),zb(d,e,f)},Ih.lineEnd=function(){a(b,c),Ih.lineEnd=Bb,Ih.point=yb}}function Db(a,b){function c(c,d){return c=a(c,d),b(c[0],c[1])}return a.invert&&b.invert&&(c.invert=function(c,d){return(c=b.invert(c,d))&&a.invert(c[0],c[1])}),c}function Eb(){return!0}function Fb(a,b,c,d,e){var f=[],g=[];if(a.forEach(function(a){if(!((b=a.length-1)<=0)){var b,c=a[0],d=a[b];if(xb(c,d)){e.lineStart();for(var h=0;h<b;++h)e.point((c=a[h])[0],c[1]);return void e.lineEnd()}var i=new Hb(c,a,null,!0),j=new Hb(c,null,i,!1);i.o=j,f.push(i),g.push(j),i=new Hb(d,a,null,!1),j=new Hb(d,null,i,!0),i.o=j,f.push(i),g.push(j)}}),g.sort(b),Gb(f),Gb(g),f.length){for(var h=0,i=c,j=g.length;h<j;++h)g[h].e=i=!i;for(var k,l,m=f[0];;){for(var n=m,o=!0;n.v;)if((n=n.n)===m)return;k=n.z,e.lineStart();do{if(n.v=n.o.v=!0,n.e){if(o)for(var h=0,j=k.length;h<j;++h)e.point((l=k[h])[0],l[1]);else d(n.x,n.n.x,1,e);n=n.n}else{if(o){k=n.p.z;for(var h=k.length-1;h>=0;--h)e.point((l=k[h])[0],l[1])}else d(n.x,n.p.x,-1,e);n=n.p}n=n.o,k=n.z,o=!o}while(!n.v);e.lineEnd()}}}function Gb(a){if(b=a.length){for(var b,c,d=0,e=a[0];++d<b;)e.n=c=a[d],c.p=e,e=c;e.n=c=a[0],c.p=e}}function Hb(a,b,c,d){this.x=a,this.z=b,this.o=c,this.e=d,this.v=!1,this.n=this.p=null}function Ib(a,b,c,d){return function(e,f){function g(b,c){var d=e(b,c);a(b=d[0],c=d[1])&&f.point(b,c)}function h(a,b){var c=e(a,b);q.point(c[0],c[1])}function i(){s.point=h,q.lineStart()}function j(){s.point=g,q.lineEnd()}function k(a,b){p.push([a,b]);var c=e(a,b);u.point(c[0],c[1])}function l(){u.lineStart(),p=[]}function m(){k(p[0][0],p[0][1]),u.lineEnd();var a,b=u.clean(),c=t.buffer(),d=c.length;if(p.pop(),o.push(p),p=null,d)if(1&b){a=c[0];var e,d=a.length-1,g=-1;if(d>0){for(v||(f.polygonStart(),v=!0),f.lineStart();++g<d;)f.point((e=a[g])[0],e[1]);f.lineEnd()}}else d>1&&2&b&&c.push(c.pop().concat(c.shift())),n.push(c.filter(Jb))}var n,o,p,q=b(f),r=e.invert(d[0],d[1]),s={point:g,lineStart:i,lineEnd:j,polygonStart:function(){s.point=k,s.lineStart=l,s.lineEnd=m,n=[],o=[]},polygonEnd:function(){s.point=g,s.lineStart=i,s.lineEnd=j,n=ig.merge(n);var a=Pb(r,o);n.length?(v||(f.polygonStart(),v=!0),Fb(n,Lb,a,c,f)):a&&(v||(f.polygonStart(),v=!0),f.lineStart(),c(null,null,1,f),f.lineEnd()),v&&(f.polygonEnd(),v=!1),n=o=null},sphere:function(){f.polygonStart(),f.lineStart(),c(null,null,1,f),f.lineEnd(),f.polygonEnd()}},t=Kb(),u=b(t),v=!1;return s}}function Jb(a){return a.length>1}function Kb(){var a,b=[];return{lineStart:function(){b.push(a=[])},point:function(b,c){a.push([b,c])},lineEnd:w,buffer:function(){var c=b;return b=[],a=null,c},rejoin:function(){b.length>1&&b.push(b.pop().concat(b.shift()))}}}function Lb(a,b){return((a=a.x)[0]<0?a[1]-Og-Jg:Og-a[1])-((b=b.x)[0]<0?b[1]-Og-Jg:Og-b[1])}function Mb(a){var b,c=NaN,d=NaN,e=NaN;return{lineStart:function(){a.lineStart(),b=1},point:function(f,g){var h=f>0?Lg:-Lg,i=sg(f-c);sg(i-Lg)<Jg?(a.point(c,d=(d+g)/2>0?Og:-Og),a.point(e,d),a.lineEnd(),a.lineStart(),a.point(h,d),a.point(f,d),b=0):e!==h&&i>=Lg&&(sg(c-e)<Jg&&(c-=e*Jg),sg(f-h)<Jg&&(f-=h*Jg),d=Nb(c,d,f,g),a.point(e,d),a.lineEnd(),a.lineStart(),a.point(h,d),b=0),a.point(c=f,d=g),e=h},lineEnd:function(){a.lineEnd(),c=d=NaN},clean:function(){return 2-b}}}function Nb(a,b,c,d){var e,f,g=Math.sin(a-c);return sg(g)>Jg?Math.atan((Math.sin(b)*(f=Math.cos(d))*Math.sin(c)-Math.sin(d)*(e=Math.cos(b))*Math.sin(a))/(e*f*g)):(b+d)/2}function Ob(a,b,c,d){var e;if(null==a)e=c*Og,d.point(-Lg,e),d.point(0,e),d.point(Lg,e),d.point(Lg,0),d.point(Lg,-e),d.point(0,-e),d.point(-Lg,-e),d.point(-Lg,0),d.point(-Lg,e);else if(sg(a[0]-b[0])>Jg){var f=a[0]<b[0]?Lg:-Lg;e=c*f/2,d.point(-f,e),d.point(0,e),d.point(f,e)}else d.point(b[0],b[1])}function Pb(a,b){var c=a[0],d=a[1],e=[Math.sin(c),-Math.cos(c),0],f=0,g=0;vh.reset();for(var h=0,i=b.length;h<i;++h){var j=b[h],k=j.length;if(k)for(var l=j[0],m=l[0],n=l[1]/2+Lg/4,o=Math.sin(n),p=Math.cos(n),q=1;;){q===k&&(q=0),a=j[q];var r=a[0],s=a[1]/2+Lg/4,t=Math.sin(s),u=Math.cos(s),v=r-m,w=v>=0?1:-1,x=w*v,y=x>Lg,z=o*t;if(vh.add(Math.atan2(z*w*Math.sin(x),p*u+z*Math.cos(x))),f+=y?v+w*Mg:v,y^m>=c^r>=c){var A=sb(qb(l),qb(a));vb(A);var B=sb(e,A);vb(B);var C=(y^v>=0?-1:1)*ca(B[2]);(d>C||d===C&&(A[0]||A[1]))&&(g+=y^v>=0?1:-1)}if(!q++)break;m=r,o=t,p=u,l=a}}return(f<-Jg||f<Jg&&vh<-Jg)^1&g}function Qb(a){function b(a,b){return Math.cos(a)*Math.cos(b)>f}function c(a){var c,f,i,j,k;return{lineStart:function(){j=i=!1,k=1},point:function(l,m){var n,o=[l,m],p=b(l,m),q=g?p?0:e(l,m):p?e(l+(l<0?Lg:-Lg),m):0;if(!c&&(j=i=p)&&a.lineStart(),p!==i&&(n=d(c,o),(xb(c,n)||xb(o,n))&&(o[0]+=Jg,o[1]+=Jg,p=b(o[0],o[1]))),p!==i)k=0,p?(a.lineStart(),n=d(o,c),a.point(n[0],n[1])):(n=d(c,o),a.point(n[0],n[1]),a.lineEnd()),c=n;else if(h&&c&&g^p){var r;q&f||!(r=d(o,c,!0))||(k=0,g?(a.lineStart(),
+a.point(r[0][0],r[0][1]),a.point(r[1][0],r[1][1]),a.lineEnd()):(a.point(r[1][0],r[1][1]),a.lineEnd(),a.lineStart(),a.point(r[0][0],r[0][1])))}!p||c&&xb(c,o)||a.point(o[0],o[1]),c=o,i=p,f=q},lineEnd:function(){i&&a.lineEnd(),c=null},clean:function(){return k|(j&&i)<<1}}}function d(a,b,c){var d=qb(a),e=qb(b),g=[1,0,0],h=sb(d,e),i=rb(h,h),j=h[0],k=i-j*j;if(!k)return!c&&a;var l=f*i/k,m=-f*j/k,n=sb(g,h),o=ub(g,l);tb(o,ub(h,m));var p=n,q=rb(o,p),r=rb(p,p),s=q*q-r*(rb(o,o)-1);if(!(s<0)){var t=Math.sqrt(s),u=ub(p,(-q-t)/r);if(tb(u,o),u=wb(u),!c)return u;var v,w=a[0],x=b[0],y=a[1],z=b[1];x<w&&(v=w,w=x,x=v);var A=x-w,B=sg(A-Lg)<Jg,C=B||A<Jg;if(!B&&z<y&&(v=y,y=z,z=v),C?B?y+z>0^u[1]<(sg(u[0]-w)<Jg?y:z):y<=u[1]&&u[1]<=z:A>Lg^(w<=u[0]&&u[0]<=x)){var D=ub(p,(-q+t)/r);return tb(D,o),[u,wb(D)]}}}function e(b,c){var d=g?a:Lg-a,e=0;return b<-d?e|=1:b>d&&(e|=2),c<-d?e|=4:c>d&&(e|=8),e}var f=Math.cos(a),g=f>0,h=sg(f)>Jg;return Ib(b,c,pc(a,6*Pg),g?[0,-a]:[-Lg,a-Lg])}function Rb(a,b,c,d){return function(e){var f,g=e.a,h=e.b,i=g.x,j=g.y,k=h.x,l=h.y,m=0,n=1,o=k-i,p=l-j;if(f=a-i,o||!(f>0)){if(f/=o,o<0){if(f<m)return;f<n&&(n=f)}else if(o>0){if(f>n)return;f>m&&(m=f)}if(f=c-i,o||!(f<0)){if(f/=o,o<0){if(f>n)return;f>m&&(m=f)}else if(o>0){if(f<m)return;f<n&&(n=f)}if(f=b-j,p||!(f>0)){if(f/=p,p<0){if(f<m)return;f<n&&(n=f)}else if(p>0){if(f>n)return;f>m&&(m=f)}if(f=d-j,p||!(f<0)){if(f/=p,p<0){if(f>n)return;f>m&&(m=f)}else if(p>0){if(f<m)return;f<n&&(n=f)}return m>0&&(e.a={x:i+m*o,y:j+m*p}),n<1&&(e.b={x:i+n*o,y:j+n*p}),e}}}}}}function Sb(a,b,c,d){function e(d,e){return sg(d[0]-a)<Jg?e>0?0:3:sg(d[0]-c)<Jg?e>0?2:1:sg(d[1]-b)<Jg?e>0?1:0:e>0?3:2}function f(a,b){return g(a.x,b.x)}function g(a,b){var c=e(a,1),d=e(b,1);return c!==d?c-d:0===c?b[1]-a[1]:1===c?a[0]-b[0]:2===c?a[1]-b[1]:b[0]-a[0]}return function(h){function i(a){for(var b=0,c=q.length,d=a[1],e=0;e<c;++e)for(var f,g=1,h=q[e],i=h.length,j=h[0];g<i;++g)f=h[g],j[1]<=d?f[1]>d&&aa(j,f,a)>0&&++b:f[1]<=d&&aa(j,f,a)<0&&--b,j=f;return 0!==b}function j(f,h,i,j){var k=0,l=0;if(null==f||(k=e(f,i))!==(l=e(h,i))||g(f,h)<0^i>0)do{j.point(0===k||3===k?a:c,k>1?d:b)}while((k=(k+i+4)%4)!==l);else j.point(h[0],h[1])}function k(e,f){return a<=e&&e<=c&&b<=f&&f<=d}function l(a,b){k(a,b)&&h.point(a,b)}function m(){D.point=o,q&&q.push(r=[]),y=!0,x=!1,v=w=NaN}function n(){p&&(o(s,t),u&&x&&B.rejoin(),p.push(B.buffer())),D.point=l,x&&h.lineEnd()}function o(a,b){a=Math.max(-Kh,Math.min(Kh,a)),b=Math.max(-Kh,Math.min(Kh,b));var c=k(a,b);if(q&&r.push([a,b]),y)s=a,t=b,u=c,y=!1,c&&(h.lineStart(),h.point(a,b));else if(c&&x)h.point(a,b);else{var d={a:{x:v,y:w},b:{x:a,y:b}};C(d)?(x||(h.lineStart(),h.point(d.a.x,d.a.y)),h.point(d.b.x,d.b.y),c||h.lineEnd(),z=!1):c&&(h.lineStart(),h.point(a,b),z=!1)}v=a,w=b,x=c}var p,q,r,s,t,u,v,w,x,y,z,A=h,B=Kb(),C=Rb(a,b,c,d),D={point:l,lineStart:m,lineEnd:n,polygonStart:function(){h=B,p=[],q=[],z=!0},polygonEnd:function(){h=A,p=ig.merge(p);var b=i([a,d]),c=z&&b,e=p.length;(c||e)&&(h.polygonStart(),c&&(h.lineStart(),j(null,null,1,h),h.lineEnd()),e&&Fb(p,f,b,j,h),h.polygonEnd()),p=q=r=null}};return D}}function Tb(a){var b=0,c=Lg/3,d=hc(a),e=d(b,c);return e.parallels=function(a){return arguments.length?d(b=a[0]*Lg/180,c=a[1]*Lg/180):[b/Lg*180,c/Lg*180]},e}function Ub(a,b){function c(a,b){var c=Math.sqrt(f-2*e*Math.sin(b))/e;return[c*Math.sin(a*=e),g-c*Math.cos(a)]}var d=Math.sin(a),e=(d+Math.sin(b))/2,f=1+d*(2*e-d),g=Math.sqrt(f)/e;return c.invert=function(a,b){var c=g-b;return[Math.atan2(a,c)/e,ca((f-(a*a+c*c)*e*e)/(2*e))]},c}function Vb(){function a(a,b){Mh+=e*a-d*b,d=a,e=b}var b,c,d,e;Rh.point=function(f,g){Rh.point=a,b=d=f,c=e=g},Rh.lineEnd=function(){a(b,c)}}function Wb(a,b){a<Nh&&(Nh=a),a>Ph&&(Ph=a),b<Oh&&(Oh=b),b>Qh&&(Qh=b)}function Xb(){function a(a,b){g.push("M",a,",",b,f)}function b(a,b){g.push("M",a,",",b),h.point=c}function c(a,b){g.push("L",a,",",b)}function d(){h.point=a}function e(){g.push("Z")}var f=Yb(4.5),g=[],h={point:a,lineStart:function(){h.point=b},lineEnd:d,polygonStart:function(){h.lineEnd=e},polygonEnd:function(){h.lineEnd=d,h.point=a},pointRadius:function(a){return f=Yb(a),h},result:function(){if(g.length){var a=g.join("");return g=[],a}}};return h}function Yb(a){return"m0,"+a+"a"+a+","+a+" 0 1,1 0,"+-2*a+"a"+a+","+a+" 0 1,1 0,"+2*a+"z"}function Zb(a,b){zh+=a,Ah+=b,++Bh}function $b(){function a(a,d){var e=a-b,f=d-c,g=Math.sqrt(e*e+f*f);Ch+=g*(b+a)/2,Dh+=g*(c+d)/2,Eh+=g,Zb(b=a,c=d)}var b,c;Th.point=function(d,e){Th.point=a,Zb(b=d,c=e)}}function _b(){Th.point=Zb}function ac(){function a(a,b){var c=a-d,f=b-e,g=Math.sqrt(c*c+f*f);Ch+=g*(d+a)/2,Dh+=g*(e+b)/2,Eh+=g,g=e*a-d*b,Fh+=g*(d+a),Gh+=g*(e+b),Hh+=3*g,Zb(d=a,e=b)}var b,c,d,e;Th.point=function(f,g){Th.point=a,Zb(b=d=f,c=e=g)},Th.lineEnd=function(){a(b,c)}}function bc(a){function b(b,c){a.moveTo(b+g,c),a.arc(b,c,g,0,Mg)}function c(b,c){a.moveTo(b,c),h.point=d}function d(b,c){a.lineTo(b,c)}function e(){h.point=b}function f(){a.closePath()}var g=4.5,h={point:b,lineStart:function(){h.point=c},lineEnd:e,polygonStart:function(){h.lineEnd=f},polygonEnd:function(){h.lineEnd=e,h.point=b},pointRadius:function(a){return g=a,h},result:w};return h}function cc(a){function b(a){return(h?d:c)(a)}function c(b){return fc(b,function(c,d){c=a(c,d),b.point(c[0],c[1])})}function d(b){function c(c,d){c=a(c,d),b.point(c[0],c[1])}function d(){t=NaN,y.point=f,b.lineStart()}function f(c,d){var f=qb([c,d]),g=a(c,d);e(t,u,s,v,w,x,t=g[0],u=g[1],s=c,v=f[0],w=f[1],x=f[2],h,b),b.point(t,u)}function g(){y.point=c,b.lineEnd()}function i(){d(),y.point=j,y.lineEnd=k}function j(a,b){f(l=a,m=b),n=t,o=u,p=v,q=w,r=x,y.point=f}function k(){e(t,u,s,v,w,x,n,o,l,p,q,r,h,b),y.lineEnd=g,g()}var l,m,n,o,p,q,r,s,t,u,v,w,x,y={point:c,lineStart:d,lineEnd:g,polygonStart:function(){b.polygonStart(),y.lineStart=i},polygonEnd:function(){b.polygonEnd(),y.lineStart=d}};return y}function e(b,c,d,h,i,j,k,l,m,n,o,p,q,r){var s=k-b,t=l-c,u=s*s+t*t;if(u>4*f&&q--){var v=h+n,w=i+o,x=j+p,y=Math.sqrt(v*v+w*w+x*x),z=Math.asin(x/=y),A=sg(sg(x)-1)<Jg||sg(d-m)<Jg?(d+m)/2:Math.atan2(w,v),B=a(A,z),C=B[0],D=B[1],E=C-b,F=D-c,G=t*E-s*F;(G*G/u>f||sg((s*E+t*F)/u-.5)>.3||h*n+i*o+j*p<g)&&(e(b,c,d,h,i,j,C,D,A,v/=y,w/=y,x,q,r),r.point(C,D),e(C,D,A,v,w,x,k,l,m,n,o,p,q,r))}}var f=.5,g=Math.cos(30*Pg),h=16;return b.precision=function(a){return arguments.length?(h=(f=a*a)>0&&16,b):Math.sqrt(f)},b}function dc(a){var b=cc(function(b,c){return a([b*Qg,c*Qg])});return function(a){return ic(b(a))}}function ec(a){this.stream=a}function fc(a,b){return{point:b,sphere:function(){a.sphere()},lineStart:function(){a.lineStart()},lineEnd:function(){a.lineEnd()},polygonStart:function(){a.polygonStart()},polygonEnd:function(){a.polygonEnd()}}}function gc(a){return hc(function(){return a})()}function hc(a){function b(a){return a=h(a[0]*Pg,a[1]*Pg),[a[0]*m+i,j-a[1]*m]}function c(a){return(a=h.invert((a[0]-i)/m,(j-a[1])/m))&&[a[0]*Qg,a[1]*Qg]}function d(){h=Db(g=lc(r,s,u),f);var a=f(p,q);return i=n-a[0]*m,j=o+a[1]*m,e()}function e(){return k&&(k.valid=!1,k=null),b}var f,g,h,i,j,k,l=cc(function(a,b){return a=f(a,b),[a[0]*m+i,j-a[1]*m]}),m=150,n=480,o=250,p=0,q=0,r=0,s=0,u=0,v=Jh,w=t,x=null,y=null;return b.stream=function(a){return k&&(k.valid=!1),k=ic(v(g,l(w(a)))),k.valid=!0,k},b.clipAngle=function(a){return arguments.length?(v=null==a?(x=a,Jh):Qb((x=+a)*Pg),e()):x},b.clipExtent=function(a){return arguments.length?(y=a,w=a?Sb(a[0][0],a[0][1],a[1][0],a[1][1]):t,e()):y},b.scale=function(a){return arguments.length?(m=+a,d()):m},b.translate=function(a){return arguments.length?(n=+a[0],o=+a[1],d()):[n,o]},b.center=function(a){return arguments.length?(p=a[0]%360*Pg,q=a[1]%360*Pg,d()):[p*Qg,q*Qg]},b.rotate=function(a){return arguments.length?(r=a[0]%360*Pg,s=a[1]%360*Pg,u=a.length>2?a[2]%360*Pg:0,d()):[r*Qg,s*Qg,u*Qg]},ig.rebind(b,l,"precision"),function(){return f=a.apply(this,arguments),b.invert=f.invert&&c,d()}}function ic(a){return fc(a,function(b,c){a.point(b*Pg,c*Pg)})}function jc(a,b){return[a,b]}function kc(a,b){return[a>Lg?a-Mg:a<-Lg?a+Mg:a,b]}function lc(a,b,c){return a?b||c?Db(nc(a),oc(b,c)):nc(a):b||c?oc(b,c):kc}function mc(a){return function(b,c){return b+=a,[b>Lg?b-Mg:b<-Lg?b+Mg:b,c]}}function nc(a){var b=mc(a);return b.invert=mc(-a),b}function oc(a,b){function c(a,b){var c=Math.cos(b),h=Math.cos(a)*c,i=Math.sin(a)*c,j=Math.sin(b),k=j*d+h*e;return[Math.atan2(i*f-k*g,h*d-j*e),ca(k*f+i*g)]}var d=Math.cos(a),e=Math.sin(a),f=Math.cos(b),g=Math.sin(b);return c.invert=function(a,b){var c=Math.cos(b),h=Math.cos(a)*c,i=Math.sin(a)*c,j=Math.sin(b),k=j*f-i*g;return[Math.atan2(i*f+j*g,h*d+k*e),ca(k*d-h*e)]},c}function pc(a,b){var c=Math.cos(a),d=Math.sin(a);return function(e,f,g,h){var i=g*b;null!=e?(e=qc(c,e),f=qc(c,f),(g>0?e<f:e>f)&&(e+=g*Mg)):(e=a+g*Mg,f=a-.5*i);for(var j,k=e;g>0?k>f:k<f;k-=i)h.point((j=wb([c,-d*Math.cos(k),-d*Math.sin(k)]))[0],j[1])}}function qc(a,b){var c=qb(b);c[0]-=a,vb(c);var d=ba(-c[1]);return((-c[2]<0?-d:d)+2*Math.PI-Jg)%(2*Math.PI)}function rc(a,b,c){var d=ig.range(a,b-Jg,c).concat(b);return function(a){return d.map(function(b){return[a,b]})}}function sc(a,b,c){var d=ig.range(a,b-Jg,c).concat(b);return function(a){return d.map(function(b){return[b,a]})}}function tc(a){return a.source}function uc(a){return a.target}function vc(a,b,c,d){var e=Math.cos(b),f=Math.sin(b),g=Math.cos(d),h=Math.sin(d),i=e*Math.cos(a),j=e*Math.sin(a),k=g*Math.cos(c),l=g*Math.sin(c),m=2*Math.asin(Math.sqrt(ga(d-b)+e*g*ga(c-a))),n=1/Math.sin(m),o=m?function(a){var b=Math.sin(a*=m)*n,c=Math.sin(m-a)*n,d=c*i+b*k,e=c*j+b*l,g=c*f+b*h;return[Math.atan2(e,d)*Qg,Math.atan2(g,Math.sqrt(d*d+e*e))*Qg]}:function(){return[a*Qg,b*Qg]};return o.distance=m,o}function wc(){function a(a,e){var f=Math.sin(e*=Pg),g=Math.cos(e),h=sg((a*=Pg)-b),i=Math.cos(h);Uh+=Math.atan2(Math.sqrt((h=g*Math.sin(h))*h+(h=d*f-c*g*i)*h),c*f+d*g*i),b=a,c=f,d=g}var b,c,d;Vh.point=function(e,f){b=e*Pg,c=Math.sin(f*=Pg),d=Math.cos(f),Vh.point=a},Vh.lineEnd=function(){Vh.point=Vh.lineEnd=w}}function xc(a,b){function c(b,c){var d=Math.cos(b),e=Math.cos(c),f=a(d*e);return[f*e*Math.sin(b),f*Math.sin(c)]}return c.invert=function(a,c){var d=Math.sqrt(a*a+c*c),e=b(d),f=Math.sin(e),g=Math.cos(e);return[Math.atan2(a*f,d*g),Math.asin(d&&c*f/d)]},c}function yc(a,b){function c(a,b){g>0?b<-Og+Jg&&(b=-Og+Jg):b>Og-Jg&&(b=Og-Jg);var c=g/Math.pow(e(b),f);return[c*Math.sin(f*a),g-c*Math.cos(f*a)]}var d=Math.cos(a),e=function(a){return Math.tan(Lg/4+a/2)},f=a===b?Math.sin(a):Math.log(d/Math.cos(b))/Math.log(e(b)/e(a)),g=d*Math.pow(e(a),f)/f;return f?(c.invert=function(a,b){var c=g-b,d=_(f)*Math.sqrt(a*a+c*c);return[Math.atan2(a,c)/f,2*Math.atan(Math.pow(g/d,1/f))-Og]},c):Ac}function zc(a,b){function c(a,b){var c=f-b;return[c*Math.sin(e*a),f-c*Math.cos(e*a)]}var d=Math.cos(a),e=a===b?Math.sin(a):(d-Math.cos(b))/(b-a),f=d/e+a;return sg(e)<Jg?jc:(c.invert=function(a,b){var c=f-b;return[Math.atan2(a,c)/e,f-_(e)*Math.sqrt(a*a+c*c)]},c)}function Ac(a,b){return[a,Math.log(Math.tan(Lg/4+b/2))]}function Bc(a){var b,c=gc(a),d=c.scale,e=c.translate,f=c.clipExtent;return c.scale=function(){var a=d.apply(c,arguments);return a===c?b?c.clipExtent(null):c:a},c.translate=function(){var a=e.apply(c,arguments);return a===c?b?c.clipExtent(null):c:a},c.clipExtent=function(a){var g=f.apply(c,arguments);if(g===c){if(b=null==a){var h=Lg*d(),i=e();f([[i[0]-h,i[1]-h],[i[0]+h,i[1]+h]])}}else b&&(g=null);return g},c.clipExtent(null)}function Cc(a,b){return[Math.log(Math.tan(Lg/4+b/2)),-a]}function Dc(a){return a[0]}function Ec(a){return a[1]}function Fc(a){for(var b=a.length,c=[0,1],d=2,e=2;e<b;e++){for(;d>1&&aa(a[c[d-2]],a[c[d-1]],a[e])<=0;)--d;c[d++]=e}return c.slice(0,d)}function Gc(a,b){return a[0]-b[0]||a[1]-b[1]}function Hc(a,b,c){return(c[0]-b[0])*(a[1]-b[1])<(c[1]-b[1])*(a[0]-b[0])}function Ic(a,b,c,d){var e=a[0],f=c[0],g=b[0]-e,h=d[0]-f,i=a[1],j=c[1],k=b[1]-i,l=d[1]-j,m=(h*(i-j)-l*(e-f))/(l*g-h*k);return[e+m*g,i+m*k]}function Jc(a){var b=a[0],c=a[a.length-1];return!(b[0]-c[0]||b[1]-c[1])}function Kc(){dd(this),this.edge=this.site=this.circle=null}function Lc(a){var b=fi.pop()||new Kc;return b.site=a,b}function Mc(a){Wc(a),ci.remove(a),fi.push(a),dd(a)}function Nc(a){var b=a.circle,c=b.x,d=b.cy,e={x:c,y:d},f=a.P,g=a.N,h=[a];Mc(a);for(var i=f;i.circle&&sg(c-i.circle.x)<Jg&&sg(d-i.circle.cy)<Jg;)f=i.P,h.unshift(i),Mc(i),i=f;h.unshift(i),Wc(i);for(var j=g;j.circle&&sg(c-j.circle.x)<Jg&&sg(d-j.circle.cy)<Jg;)g=j.N,h.push(j),Mc(j),j=g;h.push(j),Wc(j);var k,l=h.length;for(k=1;k<l;++k)j=h[k],i=h[k-1],ad(j.edge,i.site,j.site,e);i=h[0],j=h[l-1],j.edge=$c(i.site,j.site,null,e),Vc(i),Vc(j)}function Oc(a){for(var b,c,d,e,f=a.x,g=a.y,h=ci._;h;)if((d=Pc(h,g)-f)>Jg)h=h.L;else{if(!((e=f-Qc(h,g))>Jg)){d>-Jg?(b=h.P,c=h):e>-Jg?(b=h,c=h.N):b=c=h;break}if(!h.R){b=h;break}h=h.R}var i=Lc(a);if(ci.insert(b,i),b||c){if(b===c)return Wc(b),c=Lc(b.site),ci.insert(i,c),i.edge=c.edge=$c(b.site,i.site),Vc(b),void Vc(c);if(!c)return void(i.edge=$c(b.site,i.site));Wc(b),Wc(c);var j=b.site,k=j.x,l=j.y,m=a.x-k,n=a.y-l,o=c.site,p=o.x-k,q=o.y-l,r=2*(m*q-n*p),s=m*m+n*n,t=p*p+q*q,u={x:(q*s-n*t)/r+k,y:(m*t-p*s)/r+l};ad(c.edge,j,o,u),i.edge=$c(j,a,null,u),c.edge=$c(a,o,null,u),Vc(b),Vc(c)}}function Pc(a,b){var c=a.site,d=c.x,e=c.y,f=e-b;if(!f)return d;var g=a.P;if(!g)return-(1/0);c=g.site;var h=c.x,i=c.y,j=i-b;if(!j)return h;var k=h-d,l=1/f-1/j,m=k/j;return l?(-m+Math.sqrt(m*m-2*l*(k*k/(-2*j)-i+j/2+e-f/2)))/l+d:(d+h)/2}function Qc(a,b){var c=a.N;if(c)return Pc(c,b);var d=a.site;return d.y===b?d.x:1/0}function Rc(a){this.site=a,this.edges=[]}function Sc(a){for(var b,c,d,e,f,g,h,i,j,k,l=a[0][0],m=a[1][0],n=a[0][1],o=a[1][1],p=bi,q=p.length;q--;)if((f=p[q])&&f.prepare())for(h=f.edges,i=h.length,g=0;g<i;)k=h[g].end(),d=k.x,e=k.y,j=h[++g%i].start(),b=j.x,c=j.y,(sg(d-b)>Jg||sg(e-c)>Jg)&&(h.splice(g,0,new bd(_c(f.site,k,sg(d-l)<Jg&&o-e>Jg?{x:l,y:sg(b-l)<Jg?c:o}:sg(e-o)<Jg&&m-d>Jg?{x:sg(c-o)<Jg?b:m,y:o}:sg(d-m)<Jg&&e-n>Jg?{x:m,y:sg(b-m)<Jg?c:n}:sg(e-n)<Jg&&d-l>Jg?{x:sg(c-n)<Jg?b:l,y:n}:null),f.site,null)),++i)}function Tc(a,b){return b.angle-a.angle}function Uc(){dd(this),this.x=this.y=this.arc=this.site=this.cy=null}function Vc(a){var b=a.P,c=a.N;if(b&&c){var d=b.site,e=a.site,f=c.site;if(d!==f){var g=e.x,h=e.y,i=d.x-g,j=d.y-h,k=f.x-g,l=f.y-h,m=2*(i*l-j*k);if(!(m>=-Kg)){var n=i*i+j*j,o=k*k+l*l,p=(l*n-j*o)/m,q=(i*o-k*n)/m,l=q+h,r=gi.pop()||new Uc;r.arc=a,r.site=e,r.x=p+g,r.y=l+Math.sqrt(p*p+q*q),r.cy=l,a.circle=r;for(var s=null,t=ei._;t;)if(r.y<t.y||r.y===t.y&&r.x<=t.x){if(!t.L){s=t.P;break}t=t.L}else{if(!t.R){s=t;break}t=t.R}ei.insert(s,r),s||(di=r)}}}}function Wc(a){var b=a.circle;b&&(b.P||(di=b.N),ei.remove(b),gi.push(b),dd(b),a.circle=null)}function Xc(a){for(var b,c=ai,d=Rb(a[0][0],a[0][1],a[1][0],a[1][1]),e=c.length;e--;)b=c[e],(!Yc(b,a)||!d(b)||sg(b.a.x-b.b.x)<Jg&&sg(b.a.y-b.b.y)<Jg)&&(b.a=b.b=null,c.splice(e,1))}function Yc(a,b){var c=a.b;if(c)return!0;var d,e,f=a.a,g=b[0][0],h=b[1][0],i=b[0][1],j=b[1][1],k=a.l,l=a.r,m=k.x,n=k.y,o=l.x,p=l.y,q=(m+o)/2,r=(n+p)/2;if(p===n){if(q<g||q>=h)return;if(m>o){if(f){if(f.y>=j)return}else f={x:q,y:i};c={x:q,y:j}}else{if(f){if(f.y<i)return}else f={x:q,y:j};c={x:q,y:i}}}else if(d=(m-o)/(p-n),e=r-d*q,d<-1||d>1)if(m>o){if(f){if(f.y>=j)return}else f={x:(i-e)/d,y:i};c={x:(j-e)/d,y:j}}else{if(f){if(f.y<i)return}else f={x:(j-e)/d,y:j};c={x:(i-e)/d,y:i}}else if(n<p){if(f){if(f.x>=h)return}else f={x:g,y:d*g+e};c={x:h,y:d*h+e}}else{if(f){if(f.x<g)return}else f={x:h,y:d*h+e};c={x:g,y:d*g+e}}return a.a=f,a.b=c,!0}function Zc(a,b){this.l=a,this.r=b,this.a=this.b=null}function $c(a,b,c,d){var e=new Zc(a,b);return ai.push(e),c&&ad(e,a,b,c),d&&ad(e,b,a,d),bi[a.i].edges.push(new bd(e,a,b)),bi[b.i].edges.push(new bd(e,b,a)),e}function _c(a,b,c){var d=new Zc(a,null);return d.a=b,d.b=c,ai.push(d),d}function ad(a,b,c,d){a.a||a.b?a.l===c?a.b=d:a.a=d:(a.a=d,a.l=b,a.r=c)}function bd(a,b,c){var d=a.a,e=a.b;this.edge=a,this.site=b,this.angle=c?Math.atan2(c.y-b.y,c.x-b.x):a.l===b?Math.atan2(e.x-d.x,d.y-e.y):Math.atan2(d.x-e.x,e.y-d.y)}function cd(){this._=null}function dd(a){a.U=a.C=a.L=a.R=a.P=a.N=null}function ed(a,b){var c=b,d=b.R,e=c.U;e?e.L===c?e.L=d:e.R=d:a._=d,d.U=e,c.U=d,c.R=d.L,c.R&&(c.R.U=c),d.L=c}function fd(a,b){var c=b,d=b.L,e=c.U;e?e.L===c?e.L=d:e.R=d:a._=d,d.U=e,c.U=d,c.L=d.R,c.L&&(c.L.U=c),d.R=c}function gd(a){for(;a.L;)a=a.L;return a}function hd(a,b){var c,d,e,f=a.sort(id).pop();for(ai=[],bi=new Array(a.length),ci=new cd,ei=new cd;;)if(e=di,f&&(!e||f.y<e.y||f.y===e.y&&f.x<e.x))f.x===c&&f.y===d||(bi[f.i]=new Rc(f),Oc(f),c=f.x,d=f.y),f=a.pop();else{if(!e)break;Nc(e.arc)}b&&(Xc(b),Sc(b));var g={cells:bi,edges:ai};return ci=ei=ai=bi=null,g}function id(a,b){return b.y-a.y||b.x-a.x}function jd(a,b,c){return(a.x-c.x)*(b.y-a.y)-(a.x-b.x)*(c.y-a.y)}function kd(a){return a.x}function ld(a){return a.y}function md(){return{leaf:!0,nodes:[],point:null,x:null,y:null}}function nd(a,b,c,d,e,f){if(!a(b,c,d,e,f)){var g=.5*(c+e),h=.5*(d+f),i=b.nodes;i[0]&&nd(a,i[0],c,d,g,h),i[1]&&nd(a,i[1],g,d,e,h),i[2]&&nd(a,i[2],c,h,g,f),i[3]&&nd(a,i[3],g,h,e,f)}}function od(a,b,c,d,e,f,g){var h,i=1/0;return function a(j,k,l,m,n){if(!(k>f||l>g||m<d||n<e)){if(o=j.point){var o,p=b-j.x,q=c-j.y,r=p*p+q*q;if(r<i){var s=Math.sqrt(i=r);d=b-s,e=c-s,f=b+s,g=c+s,h=o}}for(var t=j.nodes,u=.5*(k+m),v=.5*(l+n),w=b>=u,x=c>=v,y=x<<1|w,z=y+4;y<z;++y)if(j=t[3&y])switch(3&y){case 0:a(j,k,l,u,v);break;case 1:a(j,u,l,m,v);break;case 2:a(j,k,v,u,n);break;case 3:a(j,u,v,m,n)}}}(a,d,e,f,g),h}function pd(a,b){a=ig.rgb(a),b=ig.rgb(b);var c=a.r,d=a.g,e=a.b,f=b.r-c,g=b.g-d,h=b.b-e;return function(a){return"#"+va(Math.round(c+f*a))+va(Math.round(d+g*a))+va(Math.round(e+h*a))}}function qd(a,b){var c,d={},e={};for(c in a)c in b?d[c]=td(a[c],b[c]):e[c]=a[c];for(c in b)c in a||(e[c]=b[c]);return function(a){for(c in d)e[c]=d[c](a);return e}}function rd(a,b){return a=+a,b=+b,function(c){return a*(1-c)+b*c}}function sd(a,b){var c,d,e,f=ii.lastIndex=ji.lastIndex=0,g=-1,h=[],i=[];for(a+="",b+="";(c=ii.exec(a))&&(d=ji.exec(b));)(e=d.index)>f&&(e=b.slice(f,e),h[g]?h[g]+=e:h[++g]=e),(c=c[0])===(d=d[0])?h[g]?h[g]+=d:h[++g]=d:(h[++g]=null,i.push({i:g,x:rd(c,d)})),f=ji.lastIndex;return f<b.length&&(e=b.slice(f),h[g]?h[g]+=e:h[++g]=e),h.length<2?i[0]?(b=i[0].x,function(a){return b(a)+""}):function(){return b}:(b=i.length,function(a){for(var c,d=0;d<b;++d)h[(c=i[d]).i]=c.x(a);return h.join("")})}function td(a,b){for(var c,d=ig.interpolators.length;--d>=0&&!(c=ig.interpolators[d](a,b)););return c}function ud(a,b){var c,d=[],e=[],f=a.length,g=b.length,h=Math.min(a.length,b.length);for(c=0;c<h;++c)d.push(td(a[c],b[c]));for(;c<f;++c)e[c]=a[c];for(;c<g;++c)e[c]=b[c];return function(a){for(c=0;c<h;++c)e[c]=d[c](a);return e}}function vd(a){return function(b){return b<=0?0:b>=1?1:a(b)}}function wd(a){return function(b){return 1-a(1-b)}}function xd(a){return function(b){return.5*(b<.5?a(2*b):2-a(2-2*b))}}function yd(a){return a*a}function zd(a){return a*a*a}function Ad(a){if(a<=0)return 0;if(a>=1)return 1;var b=a*a,c=b*a;return 4*(a<.5?c:3*(a-b)+c-.75)}function Bd(a){return function(b){return Math.pow(b,a)}}function Cd(a){return 1-Math.cos(a*Og)}function Dd(a){return Math.pow(2,10*(a-1))}function Ed(a){return 1-Math.sqrt(1-a*a)}function Fd(a,b){var c;return arguments.length<2&&(b=.45),arguments.length?c=b/Mg*Math.asin(1/a):(a=1,c=b/4),function(d){return 1+a*Math.pow(2,-10*d)*Math.sin((d-c)*Mg/b)}}function Gd(a){return a||(a=1.70158),function(b){return b*b*((a+1)*b-a)}}function Hd(a){return a<1/2.75?7.5625*a*a:a<2/2.75?7.5625*(a-=1.5/2.75)*a+.75:a<2.5/2.75?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375}function Id(a,b){a=ig.hcl(a),b=ig.hcl(b);var c=a.h,d=a.c,e=a.l,f=b.h-c,g=b.c-d,h=b.l-e;return isNaN(g)&&(g=0,d=isNaN(d)?b.c:d),isNaN(f)?(f=0,c=isNaN(c)?b.h:c):f>180?f-=360:f<-180&&(f+=360),function(a){return la(c+f*a,d+g*a,e+h*a)+""}}function Jd(a,b){a=ig.hsl(a),b=ig.hsl(b);var c=a.h,d=a.s,e=a.l,f=b.h-c,g=b.s-d,h=b.l-e;return isNaN(g)&&(g=0,d=isNaN(d)?b.s:d),isNaN(f)?(f=0,c=isNaN(c)?b.h:c):f>180?f-=360:f<-180&&(f+=360),function(a){return ja(c+f*a,d+g*a,e+h*a)+""}}function Kd(a,b){a=ig.lab(a),b=ig.lab(b);var c=a.l,d=a.a,e=a.b,f=b.l-c,g=b.a-d,h=b.b-e;return function(a){return na(c+f*a,d+g*a,e+h*a)+""}}function Ld(a,b){return b-=a,function(c){return Math.round(a+b*c)}}function Md(a){var b=[a.a,a.b],c=[a.c,a.d],d=Od(b),e=Nd(b,c),f=Od(Pd(c,b,-e))||0;b[0]*c[1]<c[0]*b[1]&&(b[0]*=-1,b[1]*=-1,d*=-1,e*=-1),this.rotate=(d?Math.atan2(b[1],b[0]):Math.atan2(-c[0],c[1]))*Qg,this.translate=[a.e,a.f],this.scale=[d,f],this.skew=f?Math.atan2(e,f)*Qg:0}function Nd(a,b){return a[0]*b[0]+a[1]*b[1]}function Od(a){var b=Math.sqrt(Nd(a,a));return b&&(a[0]/=b,a[1]/=b),b}function Pd(a,b,c){return a[0]+=c*b[0],a[1]+=c*b[1],a}function Qd(a){return a.length?a.pop()+",":""}function Rd(a,b,c,d){if(a[0]!==b[0]||a[1]!==b[1]){var e=c.push("translate(",null,",",null,")");d.push({i:e-4,x:rd(a[0],b[0])},{i:e-2,x:rd(a[1],b[1])})}else(b[0]||b[1])&&c.push("translate("+b+")")}function Sd(a,b,c,d){a!==b?(a-b>180?b+=360:b-a>180&&(a+=360),d.push({i:c.push(Qd(c)+"rotate(",null,")")-2,x:rd(a,b)})):b&&c.push(Qd(c)+"rotate("+b+")")}function Td(a,b,c,d){a!==b?d.push({i:c.push(Qd(c)+"skewX(",null,")")-2,x:rd(a,b)}):b&&c.push(Qd(c)+"skewX("+b+")")}function Ud(a,b,c,d){if(a[0]!==b[0]||a[1]!==b[1]){var e=c.push(Qd(c)+"scale(",null,",",null,")");d.push({i:e-4,x:rd(a[0],b[0])},{i:e-2,x:rd(a[1],b[1])})}else 1===b[0]&&1===b[1]||c.push(Qd(c)+"scale("+b+")")}function Vd(a,b){var c=[],d=[];return a=ig.transform(a),b=ig.transform(b),Rd(a.translate,b.translate,c,d),Sd(a.rotate,b.rotate,c,d),Td(a.skew,b.skew,c,d),Ud(a.scale,b.scale,c,d),a=b=null,function(a){for(var b,e=-1,f=d.length;++e<f;)c[(b=d[e]).i]=b.x(a);return c.join("")}}function Wd(a,b){return b=(b-=a=+a)||1/b,function(c){return(c-a)/b}}function Xd(a,b){return b=(b-=a=+a)||1/b,function(c){return Math.max(0,Math.min(1,(c-a)/b))}}function Yd(a){for(var b=a.source,c=a.target,d=$d(b,c),e=[b];b!==d;)b=b.parent,e.push(b);for(var f=e.length;c!==d;)e.splice(f,0,c),c=c.parent;return e}function Zd(a){for(var b=[],c=a.parent;null!=c;)b.push(a),a=c,c=c.parent;return b.push(a),b}function $d(a,b){if(a===b)return a;for(var c=Zd(a),d=Zd(b),e=c.pop(),f=d.pop(),g=null;e===f;)g=e,e=c.pop(),f=d.pop();return g}function _d(a){a.fixed|=2}function ae(a){a.fixed&=-7}function be(a){a.fixed|=4,a.px=a.x,a.py=a.y}function ce(a){a.fixed&=-5}function de(a,b,c){var d=0,e=0;if(a.charge=0,!a.leaf)for(var f,g=a.nodes,h=g.length,i=-1;++i<h;)null!=(f=g[i])&&(de(f,b,c),a.charge+=f.charge,d+=f.charge*f.cx,e+=f.charge*f.cy);if(a.point){a.leaf||(a.point.x+=Math.random()-.5,a.point.y+=Math.random()-.5);var j=b*c[a.point.index];a.charge+=a.pointCharge=j,d+=j*a.point.x,e+=j*a.point.y}a.cx=d/a.charge,a.cy=e/a.charge}function ee(a,b){return ig.rebind(a,b,"sort","children","value"),a.nodes=a,a.links=ke,a}function fe(a,b){for(var c=[a];null!=(a=c.pop());)if(b(a),(e=a.children)&&(d=e.length))for(var d,e;--d>=0;)c.push(e[d])}function ge(a,b){for(var c=[a],d=[];null!=(a=c.pop());)if(d.push(a),(f=a.children)&&(e=f.length))for(var e,f,g=-1;++g<e;)c.push(f[g]);for(;null!=(a=d.pop());)b(a)}function he(a){return a.children}function ie(a){return a.value}function je(a,b){return b.value-a.value}function ke(a){return ig.merge(a.map(function(a){return(a.children||[]).map(function(b){return{source:a,target:b}})}))}function le(a){return a.x}function me(a){return a.y}function ne(a,b,c){a.y0=b,a.y=c}function oe(a){return ig.range(a.length)}function pe(a){for(var b=-1,c=a[0].length,d=[];++b<c;)d[b]=0;return d}function qe(a){for(var b,c=1,d=0,e=a[0][1],f=a.length;c<f;++c)(b=a[c][1])>e&&(d=c,e=b);return d}function re(a){return a.reduce(se,0)}function se(a,b){return a+b[1]}function te(a,b){return ue(a,Math.ceil(Math.log(b.length)/Math.LN2+1))}function ue(a,b){for(var c=-1,d=+a[0],e=(a[1]-d)/b,f=[];++c<=b;)f[c]=e*c+d;return f}function ve(a){return[ig.min(a),ig.max(a)]}function we(a,b){return a.value-b.value}function xe(a,b){var c=a._pack_next;a._pack_next=b,b._pack_prev=a,b._pack_next=c,c._pack_prev=b}function ye(a,b){a._pack_next=b,b._pack_prev=a}function ze(a,b){var c=b.x-a.x,d=b.y-a.y,e=a.r+b.r;return.999*e*e>c*c+d*d}function Ae(a){function b(a){k=Math.min(a.x-a.r,k),l=Math.max(a.x+a.r,l),m=Math.min(a.y-a.r,m),n=Math.max(a.y+a.r,n)}if((c=a.children)&&(j=c.length)){var c,d,e,f,g,h,i,j,k=1/0,l=-(1/0),m=1/0,n=-(1/0);if(c.forEach(Be),d=c[0],d.x=-d.r,d.y=0,b(d),j>1&&(e=c[1],e.x=e.r,e.y=0,b(e),j>2))for(f=c[2],Ee(d,e,f),b(f),xe(d,f),d._pack_prev=f,xe(f,e),e=d._pack_next,g=3;g<j;g++){Ee(d,e,f=c[g]);var o=0,p=1,q=1;for(h=e._pack_next;h!==e;h=h._pack_next,p++)if(ze(h,f)){o=1;break}if(1==o)for(i=d._pack_prev;i!==h._pack_prev&&!ze(i,f);i=i._pack_prev,q++);o?(p<q||p==q&&e.r<d.r?ye(d,e=h):ye(d=i,e),g--):(xe(d,f),e=f,b(f))}var r=(k+l)/2,s=(m+n)/2,t=0;for(g=0;g<j;g++)f=c[g],f.x-=r,f.y-=s,t=Math.max(t,f.r+Math.sqrt(f.x*f.x+f.y*f.y));a.r=t,c.forEach(Ce)}}function Be(a){a._pack_next=a._pack_prev=a}function Ce(a){delete a._pack_next,delete a._pack_prev}function De(a,b,c,d){var e=a.children;if(a.x=b+=d*a.x,a.y=c+=d*a.y,a.r*=d,e)for(var f=-1,g=e.length;++f<g;)De(e[f],b,c,d)}function Ee(a,b,c){var d=a.r+c.r,e=b.x-a.x,f=b.y-a.y;if(d&&(e||f)){var g=b.r+c.r,h=e*e+f*f;g*=g,d*=d;var i=.5+(d-g)/(2*h),j=Math.sqrt(Math.max(0,2*g*(d+h)-(d-=h)*d-g*g))/(2*h);c.x=a.x+i*e+j*f,c.y=a.y+i*f-j*e}else c.x=a.x+d,c.y=a.y}function Fe(a,b){return a.parent==b.parent?1:2}function Ge(a){var b=a.children;return b.length?b[0]:a.t}function He(a){var b,c=a.children;return(b=c.length)?c[b-1]:a.t}function Ie(a,b,c){var d=c/(b.i-a.i);b.c-=d,b.s+=c,a.c+=d,b.z+=c,b.m+=c}function Je(a){for(var b,c=0,d=0,e=a.children,f=e.length;--f>=0;)b=e[f],b.z+=c,b.m+=c,c+=b.s+(d+=b.c)}function Ke(a,b,c){return a.a.parent===b.parent?a.a:c}function Le(a){return 1+ig.max(a,function(a){return a.y})}function Me(a){return a.reduce(function(a,b){return a+b.x},0)/a.length}function Ne(a){var b=a.children;return b&&b.length?Ne(b[0]):a}function Oe(a){var b,c=a.children;return c&&(b=c.length)?Oe(c[b-1]):a}function Pe(a){return{x:a.x,y:a.y,dx:a.dx,dy:a.dy}}function Qe(a,b){var c=a.x+b[3],d=a.y+b[0],e=a.dx-b[1]-b[3],f=a.dy-b[0]-b[2];return e<0&&(c+=e/2,e=0),f<0&&(d+=f/2,f=0),{x:c,y:d,dx:e,dy:f}}function Re(a){var b=a[0],c=a[a.length-1];return b<c?[b,c]:[c,b]}function Se(a){return a.rangeExtent?a.rangeExtent():Re(a.range())}function Te(a,b,c,d){var e=c(a[0],a[1]),f=d(b[0],b[1]);return function(a){return f(e(a))}}function Ue(a,b){var c,d=0,e=a.length-1,f=a[d],g=a[e];return g<f&&(c=d,d=e,e=c,c=f,f=g,g=c),a[d]=b.floor(f),a[e]=b.ceil(g),a}function Ve(a){return a?{floor:function(b){return Math.floor(b/a)*a},ceil:function(b){return Math.ceil(b/a)*a}}:ui}function We(a,b,c,d){var e=[],f=[],g=0,h=Math.min(a.length,b.length)-1;for(a[h]<a[0]&&(a=a.slice().reverse(),b=b.slice().reverse());++g<=h;)e.push(c(a[g-1],a[g])),f.push(d(b[g-1],b[g]));return function(b){var c=ig.bisect(a,b,1,h)-1;return f[c](e[c](b))}}function Xe(a,b,c,d){function e(){var e=Math.min(a.length,b.length)>2?We:Te,i=d?Xd:Wd;return g=e(a,b,i,c),h=e(b,a,i,td),f}function f(a){return g(a)}var g,h;return f.invert=function(a){return h(a)},f.domain=function(b){return arguments.length?(a=b.map(Number),e()):a},f.range=function(a){return arguments.length?(b=a,e()):b},f.rangeRound=function(a){return f.range(a).interpolate(Ld)},f.clamp=function(a){return arguments.length?(d=a,e()):d},f.interpolate=function(a){return arguments.length?(c=a,e()):c},f.ticks=function(b){return _e(a,b)},f.tickFormat=function(b,c){return af(a,b,c)},f.nice=function(b){return Ze(a,b),e()},f.copy=function(){return Xe(a,b,c,d)},e()}function Ye(a,b){return ig.rebind(a,b,"range","rangeRound","interpolate","clamp")}function Ze(a,b){return Ue(a,Ve($e(a,b)[2])),Ue(a,Ve($e(a,b)[2])),a}function $e(a,b){null==b&&(b=10);var c=Re(a),d=c[1]-c[0],e=Math.pow(10,Math.floor(Math.log(d/b)/Math.LN10)),f=b/d*e;return f<=.15?e*=10:f<=.35?e*=5:f<=.75&&(e*=2),c[0]=Math.ceil(c[0]/e)*e,c[1]=Math.floor(c[1]/e)*e+.5*e,c[2]=e,c}function _e(a,b){return ig.range.apply(ig,$e(a,b))}function af(a,b,c){var d=$e(a,b);if(c){var e=ih.exec(c);if(e.shift(),"s"===e[8]){var f=ig.formatPrefix(Math.max(sg(d[0]),sg(d[1])));return e[7]||(e[7]="."+bf(f.scale(d[2]))),e[8]="f",c=ig.format(e.join("")),function(a){return c(f.scale(a))+f.symbol}}e[7]||(e[7]="."+cf(e[8],d)),c=e.join("")}else c=",."+bf(d[2])+"f";return ig.format(c)}function bf(a){return-Math.floor(Math.log(a)/Math.LN10+.01)}function cf(a,b){var c=bf(b[2]);return a in vi?Math.abs(c-bf(Math.max(sg(b[0]),sg(b[1]))))+ +("e"!==a):c-2*("%"===a)}function df(a,b,c,d){function e(a){return(c?Math.log(a<0?0:a):-Math.log(a>0?0:-a))/Math.log(b)}function f(a){return c?Math.pow(b,a):-Math.pow(b,-a)}function g(b){return a(e(b))}return g.invert=function(b){return f(a.invert(b))},g.domain=function(b){return arguments.length?(c=b[0]>=0,a.domain((d=b.map(Number)).map(e)),g):d},g.base=function(c){return arguments.length?(b=+c,a.domain(d.map(e)),g):b},g.nice=function(){var b=Ue(d.map(e),c?Math:xi);return a.domain(b),d=b.map(f),g},g.ticks=function(){var a=Re(d),g=[],h=a[0],i=a[1],j=Math.floor(e(h)),k=Math.ceil(e(i)),l=b%1?2:b;if(isFinite(k-j)){if(c){for(;j<k;j++)for(var m=1;m<l;m++)g.push(f(j)*m);g.push(f(j))}else for(g.push(f(j));j++<k;)for(var m=l-1;m>0;m--)g.push(f(j)*m);for(j=0;g[j]<h;j++);for(k=g.length;g[k-1]>i;k--);g=g.slice(j,k)}return g},g.tickFormat=function(a,c){if(!arguments.length)return wi;arguments.length<2?c=wi:"function"!=typeof c&&(c=ig.format(c));var d=Math.max(1,b*a/g.ticks().length);return function(a){var g=a/f(Math.round(e(a)));return g*b<b-.5&&(g*=b),g<=d?c(a):""}},g.copy=function(){return df(a.copy(),b,c,d)},Ye(g,a)}function ef(a,b,c){function d(b){return a(e(b))}var e=ff(b),f=ff(1/b);return d.invert=function(b){return f(a.invert(b))},d.domain=function(b){return arguments.length?(a.domain((c=b.map(Number)).map(e)),d):c},d.ticks=function(a){return _e(c,a)},d.tickFormat=function(a,b){return af(c,a,b)},d.nice=function(a){return d.domain(Ze(c,a))},d.exponent=function(g){return arguments.length?(e=ff(b=g),f=ff(1/b),a.domain(c.map(e)),d):b},d.copy=function(){return ef(a.copy(),b,c)},Ye(d,a)}function ff(a){return function(b){return b<0?-Math.pow(-b,a):Math.pow(b,a)}}function gf(a,b){function c(c){return f[((e.get(c)||("range"===b.t?e.set(c,a.push(c)):NaN))-1)%f.length]}function d(b,c){return ig.range(a.length).map(function(a){return b+c*a})}var e,f,g;return c.domain=function(d){if(!arguments.length)return a;a=[],e=new k;for(var f,g=-1,h=d.length;++g<h;)e.has(f=d[g])||e.set(f,a.push(f));return c[b.t].apply(c,b.a)},c.range=function(a){return arguments.length?(f=a,g=0,b={t:"range",a:arguments},c):f},c.rangePoints=function(e,h){arguments.length<2&&(h=0);var i=e[0],j=e[1],k=a.length<2?(i=(i+j)/2,0):(j-i)/(a.length-1+h);return f=d(i+k*h/2,k),g=0,b={t:"rangePoints",a:arguments},c},c.rangeRoundPoints=function(e,h){arguments.length<2&&(h=0);var i=e[0],j=e[1],k=a.length<2?(i=j=Math.round((i+j)/2),0):(j-i)/(a.length-1+h)|0;return f=d(i+Math.round(k*h/2+(j-i-(a.length-1+h)*k)/2),k),g=0,b={t:"rangeRoundPoints",a:arguments},c},c.rangeBands=function(e,h,i){arguments.length<2&&(h=0),arguments.length<3&&(i=h);var j=e[1]<e[0],k=e[j-0],l=e[1-j],m=(l-k)/(a.length-h+2*i);return f=d(k+m*i,m),j&&f.reverse(),g=m*(1-h),b={t:"rangeBands",a:arguments},c},c.rangeRoundBands=function(e,h,i){arguments.length<2&&(h=0),arguments.length<3&&(i=h);var j=e[1]<e[0],k=e[j-0],l=e[1-j],m=Math.floor((l-k)/(a.length-h+2*i));return f=d(k+Math.round((l-k-(a.length-h)*m)/2),m),j&&f.reverse(),g=Math.round(m*(1-h)),b={t:"rangeRoundBands",a:arguments},c},c.rangeBand=function(){return g},c.rangeExtent=function(){return Re(b.a[0])},c.copy=function(){return gf(a,b)},c.domain(a)}function hf(a,b){function c(){var c=0,d=b.length;for(h=[];++c<d;)h[c-1]=ig.quantile(a,c/d);return g}function g(a){if(!isNaN(a=+a))return b[ig.bisect(h,a)]}var h;return g.domain=function(b){return arguments.length?(a=b.map(e).filter(f).sort(d),c()):a},g.range=function(a){return arguments.length?(b=a,c()):b},g.quantiles=function(){return h},g.invertExtent=function(c){return c=b.indexOf(c),c<0?[NaN,NaN]:[c>0?h[c-1]:a[0],c<h.length?h[c]:a[a.length-1]]},g.copy=function(){
+return hf(a,b)},c()}function jf(a,b,c){function d(b){return c[Math.max(0,Math.min(g,Math.floor(f*(b-a))))]}function e(){return f=c.length/(b-a),g=c.length-1,d}var f,g;return d.domain=function(c){return arguments.length?(a=+c[0],b=+c[c.length-1],e()):[a,b]},d.range=function(a){return arguments.length?(c=a,e()):c},d.invertExtent=function(b){return b=c.indexOf(b),b=b<0?NaN:b/f+a,[b,b+1/f]},d.copy=function(){return jf(a,b,c)},e()}function kf(a,b){function c(c){if(c<=c)return b[ig.bisect(a,c)]}return c.domain=function(b){return arguments.length?(a=b,c):a},c.range=function(a){return arguments.length?(b=a,c):b},c.invertExtent=function(c){return c=b.indexOf(c),[a[c-1],a[c]]},c.copy=function(){return kf(a,b)},c}function lf(a){function b(a){return+a}return b.invert=b,b.domain=b.range=function(c){return arguments.length?(a=c.map(b),b):a},b.ticks=function(b){return _e(a,b)},b.tickFormat=function(b,c){return af(a,b,c)},b.copy=function(){return lf(a)},b}function mf(){return 0}function nf(a){return a.innerRadius}function of(a){return a.outerRadius}function pf(a){return a.startAngle}function qf(a){return a.endAngle}function rf(a){return a&&a.padAngle}function sf(a,b,c,d){return(a-c)*b-(b-d)*a>0?0:1}function tf(a,b,c,d,e){var f=a[0]-b[0],g=a[1]-b[1],h=(e?d:-d)/Math.sqrt(f*f+g*g),i=h*g,j=-h*f,k=a[0]+i,l=a[1]+j,m=b[0]+i,n=b[1]+j,o=(k+m)/2,p=(l+n)/2,q=m-k,r=n-l,s=q*q+r*r,t=c-d,u=k*n-m*l,v=(r<0?-1:1)*Math.sqrt(Math.max(0,t*t*s-u*u)),w=(u*r-q*v)/s,x=(-u*q-r*v)/s,y=(u*r+q*v)/s,z=(-u*q+r*v)/s,A=w-o,B=x-p,C=y-o,D=z-p;return A*A+B*B>C*C+D*D&&(w=y,x=z),[[w-i,x-j],[w*c/t,x*c/t]]}function uf(a){function b(b){function g(){j.push("M",f(a(k),h))}for(var i,j=[],k=[],l=-1,m=b.length,n=Ba(c),o=Ba(d);++l<m;)e.call(this,i=b[l],l)?k.push([+n.call(this,i,l),+o.call(this,i,l)]):k.length&&(g(),k=[]);return k.length&&g(),j.length?j.join(""):null}var c=Dc,d=Ec,e=Eb,f=vf,g=f.key,h=.7;return b.x=function(a){return arguments.length?(c=a,b):c},b.y=function(a){return arguments.length?(d=a,b):d},b.defined=function(a){return arguments.length?(e=a,b):e},b.interpolate=function(a){return arguments.length?(g="function"==typeof a?f=a:(f=Di.get(a)||vf).key,b):g},b.tension=function(a){return arguments.length?(h=a,b):h},b}function vf(a){return a.length>1?a.join("L"):a+"Z"}function wf(a){return a.join("L")+"Z"}function xf(a){for(var b=0,c=a.length,d=a[0],e=[d[0],",",d[1]];++b<c;)e.push("H",(d[0]+(d=a[b])[0])/2,"V",d[1]);return c>1&&e.push("H",d[0]),e.join("")}function yf(a){for(var b=0,c=a.length,d=a[0],e=[d[0],",",d[1]];++b<c;)e.push("V",(d=a[b])[1],"H",d[0]);return e.join("")}function zf(a){for(var b=0,c=a.length,d=a[0],e=[d[0],",",d[1]];++b<c;)e.push("H",(d=a[b])[0],"V",d[1]);return e.join("")}function Af(a,b){return a.length<4?vf(a):a[1]+Df(a.slice(1,-1),Ef(a,b))}function Bf(a,b){return a.length<3?wf(a):a[0]+Df((a.push(a[0]),a),Ef([a[a.length-2]].concat(a,[a[1]]),b))}function Cf(a,b){return a.length<3?vf(a):a[0]+Df(a,Ef(a,b))}function Df(a,b){if(b.length<1||a.length!=b.length&&a.length!=b.length+2)return vf(a);var c=a.length!=b.length,d="",e=a[0],f=a[1],g=b[0],h=g,i=1;if(c&&(d+="Q"+(f[0]-2*g[0]/3)+","+(f[1]-2*g[1]/3)+","+f[0]+","+f[1],e=a[1],i=2),b.length>1){h=b[1],f=a[i],i++,d+="C"+(e[0]+g[0])+","+(e[1]+g[1])+","+(f[0]-h[0])+","+(f[1]-h[1])+","+f[0]+","+f[1];for(var j=2;j<b.length;j++,i++)f=a[i],h=b[j],d+="S"+(f[0]-h[0])+","+(f[1]-h[1])+","+f[0]+","+f[1]}if(c){var k=a[i];d+="Q"+(f[0]+2*h[0]/3)+","+(f[1]+2*h[1]/3)+","+k[0]+","+k[1]}return d}function Ef(a,b){for(var c,d=[],e=(1-b)/2,f=a[0],g=a[1],h=1,i=a.length;++h<i;)c=f,f=g,g=a[h],d.push([e*(g[0]-c[0]),e*(g[1]-c[1])]);return d}function Ff(a){if(a.length<3)return vf(a);var b=1,c=a.length,d=a[0],e=d[0],f=d[1],g=[e,e,e,(d=a[1])[0]],h=[f,f,f,d[1]],i=[e,",",f,"L",Jf(Gi,g),",",Jf(Gi,h)];for(a.push(a[c-1]);++b<=c;)d=a[b],g.shift(),g.push(d[0]),h.shift(),h.push(d[1]),Kf(i,g,h);return a.pop(),i.push("L",d),i.join("")}function Gf(a){if(a.length<4)return vf(a);for(var b,c=[],d=-1,e=a.length,f=[0],g=[0];++d<3;)b=a[d],f.push(b[0]),g.push(b[1]);for(c.push(Jf(Gi,f)+","+Jf(Gi,g)),--d;++d<e;)b=a[d],f.shift(),f.push(b[0]),g.shift(),g.push(b[1]),Kf(c,f,g);return c.join("")}function Hf(a){for(var b,c,d=-1,e=a.length,f=e+4,g=[],h=[];++d<4;)c=a[d%e],g.push(c[0]),h.push(c[1]);for(b=[Jf(Gi,g),",",Jf(Gi,h)],--d;++d<f;)c=a[d%e],g.shift(),g.push(c[0]),h.shift(),h.push(c[1]),Kf(b,g,h);return b.join("")}function If(a,b){var c=a.length-1;if(c)for(var d,e,f=a[0][0],g=a[0][1],h=a[c][0]-f,i=a[c][1]-g,j=-1;++j<=c;)d=a[j],e=j/c,d[0]=b*d[0]+(1-b)*(f+e*h),d[1]=b*d[1]+(1-b)*(g+e*i);return Ff(a)}function Jf(a,b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3]}function Kf(a,b,c){a.push("C",Jf(Ei,b),",",Jf(Ei,c),",",Jf(Fi,b),",",Jf(Fi,c),",",Jf(Gi,b),",",Jf(Gi,c))}function Lf(a,b){return(b[1]-a[1])/(b[0]-a[0])}function Mf(a){for(var b=0,c=a.length-1,d=[],e=a[0],f=a[1],g=d[0]=Lf(e,f);++b<c;)d[b]=(g+(g=Lf(e=f,f=a[b+1])))/2;return d[b]=g,d}function Nf(a){for(var b,c,d,e,f=[],g=Mf(a),h=-1,i=a.length-1;++h<i;)b=Lf(a[h],a[h+1]),sg(b)<Jg?g[h]=g[h+1]=0:(c=g[h]/b,d=g[h+1]/b,(e=c*c+d*d)>9&&(e=3*b/Math.sqrt(e),g[h]=e*c,g[h+1]=e*d));for(h=-1;++h<=i;)e=(a[Math.min(i,h+1)][0]-a[Math.max(0,h-1)][0])/(6*(1+g[h]*g[h])),f.push([e||0,g[h]*e||0]);return f}function Of(a){return a.length<3?vf(a):a[0]+Df(a,Nf(a))}function Pf(a){for(var b,c,d,e=-1,f=a.length;++e<f;)b=a[e],c=b[0],d=b[1]-Og,b[0]=c*Math.cos(d),b[1]=c*Math.sin(d);return a}function Qf(a){function b(b){function i(){p.push("M",h(a(r),l),k,j(a(q.reverse()),l),"Z")}for(var m,n,o,p=[],q=[],r=[],s=-1,t=b.length,u=Ba(c),v=Ba(e),w=c===d?function(){return n}:Ba(d),x=e===f?function(){return o}:Ba(f);++s<t;)g.call(this,m=b[s],s)?(q.push([n=+u.call(this,m,s),o=+v.call(this,m,s)]),r.push([+w.call(this,m,s),+x.call(this,m,s)])):q.length&&(i(),q=[],r=[]);return q.length&&i(),p.length?p.join(""):null}var c=Dc,d=Dc,e=0,f=Ec,g=Eb,h=vf,i=h.key,j=h,k="L",l=.7;return b.x=function(a){return arguments.length?(c=d=a,b):d},b.x0=function(a){return arguments.length?(c=a,b):c},b.x1=function(a){return arguments.length?(d=a,b):d},b.y=function(a){return arguments.length?(e=f=a,b):f},b.y0=function(a){return arguments.length?(e=a,b):e},b.y1=function(a){return arguments.length?(f=a,b):f},b.defined=function(a){return arguments.length?(g=a,b):g},b.interpolate=function(a){return arguments.length?(i="function"==typeof a?h=a:(h=Di.get(a)||vf).key,j=h.reverse||h,k=h.closed?"M":"L",b):i},b.tension=function(a){return arguments.length?(l=a,b):l},b}function Rf(a){return a.radius}function Sf(a){return[a.x,a.y]}function Tf(a){return function(){var b=a.apply(this,arguments),c=b[0],d=b[1]-Og;return[c*Math.cos(d),c*Math.sin(d)]}}function Uf(){return 64}function Vf(){return"circle"}function Wf(a){var b=Math.sqrt(a/Lg);return"M0,"+b+"A"+b+","+b+" 0 1,1 0,"+-b+"A"+b+","+b+" 0 1,1 0,"+b+"Z"}function Xf(a){return function(){var b,c,d;(b=this[a])&&(d=b[c=b.active])&&(d.timer.c=null,d.timer.t=NaN,--b.count?delete b[c]:delete this[a],b.active+=.5,d.event&&d.event.interrupt.call(this,this.__data__,d.index))}}function Yf(a,b,c){return xg(a,Ni),a.namespace=b,a.id=c,a}function Zf(a,b,c,d){var e=a.id,f=a.namespace;return S(a,"function"==typeof c?function(a,g,h){a[f][e].tween.set(b,d(c.call(a,a.__data__,g,h)))}:(c=d(c),function(a){a[f][e].tween.set(b,c)}))}function $f(a){return null==a&&(a=""),function(){this.textContent=a}}function _f(a){return null==a?"__transition__":"__transition_"+a+"__"}function ag(a,b,c,d,e){function f(a){var b=p.delay;if(j.t=b+i,b<=a)return g(a-b);j.c=g}function g(c){var e=o.active,f=o[e];f&&(f.timer.c=null,f.timer.t=NaN,--o.count,delete o[e],f.event&&f.event.interrupt.call(a,a.__data__,f.index));for(var g in o)if(+g<d){var k=o[g];k.timer.c=null,k.timer.t=NaN,--o.count,delete o[g]}j.c=h,Ga(function(){return j.c&&h(c||1)&&(j.c=null,j.t=NaN),1},0,i),o.active=d,p.event&&p.event.start.call(a,a.__data__,b),n=[],p.tween.forEach(function(c,d){(d=d.call(a,a.__data__,b))&&n.push(d)}),m=p.ease,l=p.duration}function h(e){for(var f=e/l,g=m(f),h=n.length;h>0;)n[--h].call(a,g);if(f>=1)return p.event&&p.event.end.call(a,a.__data__,b),--o.count?delete o[d]:delete a[c],1}var i,j,l,m,n,o=a[c]||(a[c]={active:0,count:0}),p=o[d];p||(i=e.time,j=Ga(f,0,i),p=o[d]={tween:new k,time:i,timer:j,delay:e.delay,duration:e.duration,ease:e.ease,index:b},e=null,++o.count)}function bg(a,b,c){a.attr("transform",function(a){var d=b(a);return"translate("+(isFinite(d)?d:c(a))+",0)"})}function cg(a,b,c){a.attr("transform",function(a){var d=b(a);return"translate(0,"+(isFinite(d)?d:c(a))+")"})}function dg(a){return a.toISOString()}function eg(a,b,c){function d(b){return a(b)}function e(a,c){var d=a[1]-a[0],e=d/c,f=ig.bisect(Wi,e);return f==Wi.length?[b.year,$e(a.map(function(a){return a/31536e6}),c)[2]]:f?b[e/Wi[f-1]<Wi[f]/e?f-1:f]:[Zi,$e(a,c)[2]]}return d.invert=function(b){return fg(a.invert(b))},d.domain=function(b){return arguments.length?(a.domain(b),d):a.domain().map(fg)},d.nice=function(a,b){function c(c){return!isNaN(c)&&!a.range(c,fg(+c+1),b).length}var f=d.domain(),g=Re(f),h=null==a?e(g,10):"number"==typeof a&&e(g,a);return h&&(a=h[0],b=h[1]),d.domain(Ue(f,b>1?{floor:function(b){for(;c(b=a.floor(b));)b=fg(b-1);return b},ceil:function(b){for(;c(b=a.ceil(b));)b=fg(+b+1);return b}}:a))},d.ticks=function(a,b){var c=Re(d.domain()),f=null==a?e(c,10):"number"==typeof a?e(c,a):!a.range&&[{range:a},b];return f&&(a=f[0],b=f[1]),a.range(c[0],fg(+c[1]+1),b<1?1:b)},d.tickFormat=function(){return c},d.copy=function(){return eg(a.copy(),b,c)},Ye(d,a)}function fg(a){return new Date(a)}function gg(a){return JSON.parse(a.responseText)}function hg(a){var b=lg.createRange();return b.selectNode(lg.body),b.createContextualFragment(a.responseText)}var ig={version:"3.5.17"},jg=[].slice,kg=function(a){return jg.call(a)},lg=this.document;if(lg)try{kg(lg.documentElement.childNodes)[0].nodeType}catch(a){kg=function(a){for(var b=a.length,c=new Array(b);b--;)c[b]=a[b];return c}}if(Date.now||(Date.now=function(){return+new Date}),lg)try{lg.createElement("DIV").style.setProperty("opacity",0,"")}catch(a){var mg=this.Element.prototype,ng=mg.setAttribute,og=mg.setAttributeNS,pg=this.CSSStyleDeclaration.prototype,qg=pg.setProperty;mg.setAttribute=function(a,b){ng.call(this,a,b+"")},mg.setAttributeNS=function(a,b,c){og.call(this,a,b,c+"")},pg.setProperty=function(a,b,c){qg.call(this,a,b+"",c)}}ig.ascending=d,ig.descending=function(a,b){return b<a?-1:b>a?1:b>=a?0:NaN},ig.min=function(a,b){var c,d,e=-1,f=a.length;if(1===arguments.length){for(;++e<f;)if(null!=(d=a[e])&&d>=d){c=d;break}for(;++e<f;)null!=(d=a[e])&&c>d&&(c=d)}else{for(;++e<f;)if(null!=(d=b.call(a,a[e],e))&&d>=d){c=d;break}for(;++e<f;)null!=(d=b.call(a,a[e],e))&&c>d&&(c=d)}return c},ig.max=function(a,b){var c,d,e=-1,f=a.length;if(1===arguments.length){for(;++e<f;)if(null!=(d=a[e])&&d>=d){c=d;break}for(;++e<f;)null!=(d=a[e])&&d>c&&(c=d)}else{for(;++e<f;)if(null!=(d=b.call(a,a[e],e))&&d>=d){c=d;break}for(;++e<f;)null!=(d=b.call(a,a[e],e))&&d>c&&(c=d)}return c},ig.extent=function(a,b){var c,d,e,f=-1,g=a.length;if(1===arguments.length){for(;++f<g;)if(null!=(d=a[f])&&d>=d){c=e=d;break}for(;++f<g;)null!=(d=a[f])&&(c>d&&(c=d),e<d&&(e=d))}else{for(;++f<g;)if(null!=(d=b.call(a,a[f],f))&&d>=d){c=e=d;break}for(;++f<g;)null!=(d=b.call(a,a[f],f))&&(c>d&&(c=d),e<d&&(e=d))}return[c,e]},ig.sum=function(a,b){var c,d=0,e=a.length,g=-1;if(1===arguments.length)for(;++g<e;)f(c=+a[g])&&(d+=c);else for(;++g<e;)f(c=+b.call(a,a[g],g))&&(d+=c);return d},ig.mean=function(a,b){var c,d=0,g=a.length,h=-1,i=g;if(1===arguments.length)for(;++h<g;)f(c=e(a[h]))?d+=c:--i;else for(;++h<g;)f(c=e(b.call(a,a[h],h)))?d+=c:--i;if(i)return d/i},ig.quantile=function(a,b){var c=(a.length-1)*b+1,d=Math.floor(c),e=+a[d-1],f=c-d;return f?e+f*(a[d]-e):e},ig.median=function(a,b){var c,g=[],h=a.length,i=-1;if(1===arguments.length)for(;++i<h;)f(c=e(a[i]))&&g.push(c);else for(;++i<h;)f(c=e(b.call(a,a[i],i)))&&g.push(c);if(g.length)return ig.quantile(g.sort(d),.5)},ig.variance=function(a,b){var c,d,g=a.length,h=0,i=0,j=-1,k=0;if(1===arguments.length)for(;++j<g;)f(c=e(a[j]))&&(d=c-h,h+=d/++k,i+=d*(c-h));else for(;++j<g;)f(c=e(b.call(a,a[j],j)))&&(d=c-h,h+=d/++k,i+=d*(c-h));if(k>1)return i/(k-1)},ig.deviation=function(){var a=ig.variance.apply(this,arguments);return a?Math.sqrt(a):a};var rg=g(d);ig.bisectLeft=rg.left,ig.bisect=ig.bisectRight=rg.right,ig.bisector=function(a){return g(1===a.length?function(b,c){return d(a(b),c)}:a)},ig.shuffle=function(a,b,c){(f=arguments.length)<3&&(c=a.length,f<2&&(b=0));for(var d,e,f=c-b;f;)e=Math.random()*f--|0,d=a[f+b],a[f+b]=a[e+b],a[e+b]=d;return a},ig.permute=function(a,b){for(var c=b.length,d=new Array(c);c--;)d[c]=a[b[c]];return d},ig.pairs=function(a){for(var b=0,c=a.length-1,d=a[0],e=new Array(c<0?0:c);b<c;)e[b]=[d,d=a[++b]];return e},ig.transpose=function(a){if(!(e=a.length))return[];for(var b=-1,c=ig.min(a,h),d=new Array(c);++b<c;)for(var e,f=-1,g=d[b]=new Array(e);++f<e;)g[f]=a[f][b];return d},ig.zip=function(){return ig.transpose(arguments)},ig.keys=function(a){var b=[];for(var c in a)b.push(c);return b},ig.values=function(a){var b=[];for(var c in a)b.push(a[c]);return b},ig.entries=function(a){var b=[];for(var c in a)b.push({key:c,value:a[c]});return b},ig.merge=function(a){for(var b,c,d,e=a.length,f=-1,g=0;++f<e;)g+=a[f].length;for(c=new Array(g);--e>=0;)for(d=a[e],b=d.length;--b>=0;)c[--g]=d[b];return c};var sg=Math.abs;ig.range=function(a,b,c){if(arguments.length<3&&(c=1,arguments.length<2&&(b=a,a=0)),(b-a)/c==1/0)throw new Error("infinite range");var d,e=[],f=i(sg(c)),g=-1;if(a*=f,b*=f,c*=f,c<0)for(;(d=a+c*++g)>b;)e.push(d/f);else for(;(d=a+c*++g)<b;)e.push(d/f);return e},ig.map=function(a,b){var c=new k;if(a instanceof k)a.forEach(function(a,b){c.set(a,b)});else if(Array.isArray(a)){var d,e=-1,f=a.length;if(1===arguments.length)for(;++e<f;)c.set(e,a[e]);else for(;++e<f;)c.set(b.call(a,d=a[e],e),d)}else for(var g in a)c.set(g,a[g]);return c};var tg="__proto__",ug="\0";j(k,{has:n,get:function(a){return this._[l(a)]},set:function(a,b){return this._[l(a)]=b},remove:o,keys:p,values:function(){var a=[];for(var b in this._)a.push(this._[b]);return a},entries:function(){var a=[];for(var b in this._)a.push({key:m(b),value:this._[b]});return a},size:q,empty:r,forEach:function(a){for(var b in this._)a.call(this,m(b),this._[b])}}),ig.nest=function(){function a(b,g,h){if(h>=f.length)return d?d.call(e,g):c?g.sort(c):g;for(var i,j,l,m,n=-1,o=g.length,p=f[h++],q=new k;++n<o;)(m=q.get(i=p(j=g[n])))?m.push(j):q.set(i,[j]);return b?(j=b(),l=function(c,d){j.set(c,a(b,d,h))}):(j={},l=function(c,d){j[c]=a(b,d,h)}),q.forEach(l),j}function b(a,c){if(c>=f.length)return a;var d=[],e=g[c++];return a.forEach(function(a,e){d.push({key:a,values:b(e,c)})}),e?d.sort(function(a,b){return e(a.key,b.key)}):d}var c,d,e={},f=[],g=[];return e.map=function(b,c){return a(c,b,0)},e.entries=function(c){return b(a(ig.map,c,0),0)},e.key=function(a){return f.push(a),e},e.sortKeys=function(a){return g[f.length-1]=a,e},e.sortValues=function(a){return c=a,e},e.rollup=function(a){return d=a,e},e},ig.set=function(a){var b=new s;if(a)for(var c=0,d=a.length;c<d;++c)b.add(a[c]);return b},j(s,{has:n,add:function(a){return this._[l(a+="")]=!0,a},remove:o,values:p,size:q,empty:r,forEach:function(a){for(var b in this._)a.call(this,m(b))}}),ig.behavior={},ig.rebind=function(a,b){for(var c,d=1,e=arguments.length;++d<e;)a[c=arguments[d]]=u(a,b,b[c]);return a};var vg=["webkit","ms","moz","Moz","o","O"];ig.dispatch=function(){for(var a=new x,b=-1,c=arguments.length;++b<c;)a[arguments[b]]=y(a);return a},x.prototype.on=function(a,b){var c=a.indexOf("."),d="";if(c>=0&&(d=a.slice(c+1),a=a.slice(0,c)),a)return arguments.length<2?this[a].on(d):this[a].on(d,b);if(2===arguments.length){if(null==b)for(a in this)this.hasOwnProperty(a)&&this[a].on(d,null);return this}},ig.event=null,ig.requote=function(a){return a.replace(wg,"\\$&")};var wg=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g,xg={}.__proto__?function(a,b){a.__proto__=b}:function(a,b){for(var c in b)a[c]=b[c]},yg=function(a,b){return b.querySelector(a)},zg=function(a,b){return b.querySelectorAll(a)},Ag=function(a,b){var c=a.matches||a[v(a,"matchesSelector")];return(Ag=function(a,b){return c.call(a,b)})(a,b)};"function"==typeof Sizzle&&(yg=function(a,b){return Sizzle(a,b)[0]||null},zg=Sizzle,Ag=Sizzle.matchesSelector),ig.selection=function(){return ig.select(lg.documentElement)};var Bg=ig.selection.prototype=[];Bg.select=function(a){var b,c,d,e,f=[];a=D(a);for(var g=-1,h=this.length;++g<h;){f.push(b=[]),b.parentNode=(d=this[g]).parentNode;for(var i=-1,j=d.length;++i<j;)(e=d[i])?(b.push(c=a.call(e,e.__data__,i,g)),c&&"__data__"in e&&(c.__data__=e.__data__)):b.push(null)}return C(f)},Bg.selectAll=function(a){var b,c,d=[];a=E(a);for(var e=-1,f=this.length;++e<f;)for(var g=this[e],h=-1,i=g.length;++h<i;)(c=g[h])&&(d.push(b=kg(a.call(c,c.__data__,h,e))),b.parentNode=c);return C(d)};var Cg="http://www.w3.org/1999/xhtml",Dg={svg:"http://www.w3.org/2000/svg",xhtml:Cg,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};ig.ns={prefix:Dg,qualify:function(a){var b=a.indexOf(":"),c=a;return b>=0&&"xmlns"!==(c=a.slice(0,b))&&(a=a.slice(b+1)),Dg.hasOwnProperty(c)?{space:Dg[c],local:a}:a}},Bg.attr=function(a,b){if(arguments.length<2){if("string"==typeof a){var c=this.node();return a=ig.ns.qualify(a),a.local?c.getAttributeNS(a.space,a.local):c.getAttribute(a)}for(b in a)this.each(F(b,a[b]));return this}return this.each(F(a,b))},Bg.classed=function(a,b){if(arguments.length<2){if("string"==typeof a){var c=this.node(),d=(a=I(a)).length,e=-1;if(b=c.classList){for(;++e<d;)if(!b.contains(a[e]))return!1}else for(b=c.getAttribute("class");++e<d;)if(!H(a[e]).test(b))return!1;return!0}for(b in a)this.each(J(b,a[b]));return this}return this.each(J(a,b))},Bg.style=function(a,b,d){var e=arguments.length;if(e<3){if("string"!=typeof a){e<2&&(b="");for(d in a)this.each(L(d,a[d],b));return this}if(e<2){var f=this.node();return c(f).getComputedStyle(f,null).getPropertyValue(a)}d=""}return this.each(L(a,b,d))},Bg.property=function(a,b){if(arguments.length<2){if("string"==typeof a)return this.node()[a];for(b in a)this.each(M(b,a[b]));return this}return this.each(M(a,b))},Bg.text=function(a){return arguments.length?this.each("function"==typeof a?function(){var b=a.apply(this,arguments);this.textContent=null==b?"":b}:null==a?function(){this.textContent=""}:function(){this.textContent=a}):this.node().textContent},Bg.html=function(a){return arguments.length?this.each("function"==typeof a?function(){var b=a.apply(this,arguments);this.innerHTML=null==b?"":b}:null==a?function(){this.innerHTML=""}:function(){this.innerHTML=a}):this.node().innerHTML},Bg.append=function(a){return a=N(a),this.select(function(){return this.appendChild(a.apply(this,arguments))})},Bg.insert=function(a,b){return a=N(a),b=D(b),this.select(function(){return this.insertBefore(a.apply(this,arguments),b.apply(this,arguments)||null)})},Bg.remove=function(){return this.each(O)},Bg.data=function(a,b){function c(a,c){var d,e,f,g=a.length,l=c.length,m=Math.min(g,l),n=new Array(l),o=new Array(l),p=new Array(g);if(b){var q,r=new k,s=new Array(g);for(d=-1;++d<g;)(e=a[d])&&(r.has(q=b.call(e,e.__data__,d))?p[d]=e:r.set(q,e),s[d]=q);for(d=-1;++d<l;)(e=r.get(q=b.call(c,f=c[d],d)))?e!==!0&&(n[d]=e,e.__data__=f):o[d]=P(f),r.set(q,!0);for(d=-1;++d<g;)d in s&&r.get(s[d])!==!0&&(p[d]=a[d])}else{for(d=-1;++d<m;)e=a[d],f=c[d],e?(e.__data__=f,n[d]=e):o[d]=P(f);for(;d<l;++d)o[d]=P(c[d]);for(;d<g;++d)p[d]=a[d]}o.update=n,o.parentNode=n.parentNode=p.parentNode=a.parentNode,h.push(o),i.push(n),j.push(p)}var d,e,f=-1,g=this.length;if(!arguments.length){for(a=new Array(g=(d=this[0]).length);++f<g;)(e=d[f])&&(a[f]=e.__data__);return a}var h=T([]),i=C([]),j=C([]);if("function"==typeof a)for(;++f<g;)c(d=this[f],a.call(d,d.parentNode.__data__,f));else for(;++f<g;)c(d=this[f],a);return i.enter=function(){return h},i.exit=function(){return j},i},Bg.datum=function(a){return arguments.length?this.property("__data__",a):this.property("__data__")},Bg.filter=function(a){var b,c,d,e=[];"function"!=typeof a&&(a=Q(a));for(var f=0,g=this.length;f<g;f++){e.push(b=[]),b.parentNode=(c=this[f]).parentNode;for(var h=0,i=c.length;h<i;h++)(d=c[h])&&a.call(d,d.__data__,h,f)&&b.push(d)}return C(e)},Bg.order=function(){for(var a=-1,b=this.length;++a<b;)for(var c,d=this[a],e=d.length-1,f=d[e];--e>=0;)(c=d[e])&&(f&&f!==c.nextSibling&&f.parentNode.insertBefore(c,f),f=c);return this},Bg.sort=function(a){a=R.apply(this,arguments);for(var b=-1,c=this.length;++b<c;)this[b].sort(a);return this.order()},Bg.each=function(a){return S(this,function(b,c,d){a.call(b,b.__data__,c,d)})},Bg.call=function(a){var b=kg(arguments);return a.apply(b[0]=this,b),this},Bg.empty=function(){return!this.node()},Bg.node=function(){for(var a=0,b=this.length;a<b;a++)for(var c=this[a],d=0,e=c.length;d<e;d++){var f=c[d];if(f)return f}return null},Bg.size=function(){var a=0;return S(this,function(){++a}),a};var Eg=[];ig.selection.enter=T,ig.selection.enter.prototype=Eg,Eg.append=Bg.append,Eg.empty=Bg.empty,Eg.node=Bg.node,Eg.call=Bg.call,Eg.size=Bg.size,Eg.select=function(a){for(var b,c,d,e,f,g=[],h=-1,i=this.length;++h<i;){d=(e=this[h]).update,g.push(b=[]),b.parentNode=e.parentNode;for(var j=-1,k=e.length;++j<k;)(f=e[j])?(b.push(d[j]=c=a.call(e.parentNode,f.__data__,j,h)),c.__data__=f.__data__):b.push(null)}return C(g)},Eg.insert=function(a,b){return arguments.length<2&&(b=U(this)),Bg.insert.call(this,a,b)},ig.select=function(b){var c;return"string"==typeof b?(c=[yg(b,lg)],c.parentNode=lg.documentElement):(c=[b],c.parentNode=a(b)),C([c])},ig.selectAll=function(a){var b;return"string"==typeof a?(b=kg(zg(a,lg)),b.parentNode=lg.documentElement):(b=kg(a),b.parentNode=null),C([b])},Bg.on=function(a,b,c){var d=arguments.length;if(d<3){if("string"!=typeof a){d<2&&(b=!1);for(c in a)this.each(V(c,a[c],b));return this}if(d<2)return(d=this.node()["__on"+a])&&d._;c=!1}return this.each(V(a,b,c))};var Fg=ig.map({mouseenter:"mouseover",mouseleave:"mouseout"});lg&&Fg.forEach(function(a){"on"+a in lg&&Fg.remove(a)});var Gg,Hg=0;ig.mouse=function(a){return Z(a,A())};var Ig=this.navigator&&/WebKit/.test(this.navigator.userAgent)?-1:0;ig.touch=function(a,b,c){if(arguments.length<3&&(c=b,b=A().changedTouches),b)for(var d,e=0,f=b.length;e<f;++e)if((d=b[e]).identifier===c)return Z(a,d)},ig.behavior.drag=function(){function a(){this.on("mousedown.drag",f).on("touchstart.drag",g)}function b(a,b,c,f,g){return function(){function h(){var a,c,d=b(m,p);d&&(a=d[0]-t[0],c=d[1]-t[1],o|=a|c,t=d,n({type:"drag",x:d[0]+j[0],y:d[1]+j[1],dx:a,dy:c}))}function i(){b(m,p)&&(r.on(f+q,null).on(g+q,null),s(o),n({type:"dragend"}))}var j,k=this,l=ig.event.target.correspondingElement||ig.event.target,m=k.parentNode,n=d.of(k,arguments),o=0,p=a(),q=".drag"+(null==p?"":"-"+p),r=ig.select(c(l)).on(f+q,h).on(g+q,i),s=Y(l),t=b(m,p);e?(j=e.apply(k,arguments),j=[j.x-t[0],j.y-t[1]]):j=[0,0],n({type:"dragstart"})}}var d=B(a,"drag","dragstart","dragend"),e=null,f=b(w,ig.mouse,c,"mousemove","mouseup"),g=b($,ig.touch,t,"touchmove","touchend");return a.origin=function(b){return arguments.length?(e=b,a):e},ig.rebind(a,d,"on")},ig.touches=function(a,b){return arguments.length<2&&(b=A().touches),b?kg(b).map(function(b){var c=Z(a,b);return c.identifier=b.identifier,c}):[]};var Jg=1e-6,Kg=Jg*Jg,Lg=Math.PI,Mg=2*Lg,Ng=Mg-Jg,Og=Lg/2,Pg=Lg/180,Qg=180/Lg,Rg=Math.SQRT2;ig.interpolateZoom=function(a,b){var c,d,e=a[0],f=a[1],g=a[2],h=b[0],i=b[1],j=b[2],k=h-e,l=i-f,m=k*k+l*l;if(m<Kg)d=Math.log(j/g)/Rg,c=function(a){return[e+a*k,f+a*l,g*Math.exp(Rg*a*d)]};else{var n=Math.sqrt(m),o=(j*j-g*g+4*m)/(2*g*2*n),p=(j*j-g*g-4*m)/(2*j*2*n),q=Math.log(Math.sqrt(o*o+1)-o);d=(Math.log(Math.sqrt(p*p+1)-p)-q)/Rg,c=function(a){var b=a*d,c=ea(q),h=g/(2*n)*(c*fa(Rg*b+q)-da(q));return[e+h*k,f+h*l,g*c/ea(Rg*b+q)]}}return c.duration=1e3*d,c},ig.behavior.zoom=function(){function a(a){a.on(F,l).on(Tg+".zoom",n).on("dblclick.zoom",o).on(I,m)}function b(a){return[(a[0]-y.x)/y.k,(a[1]-y.y)/y.k]}function d(a){return[a[0]*y.k+y.x,a[1]*y.k+y.y]}function e(a){y.k=Math.max(C[0],Math.min(C[1],a))}function f(a,b){b=d(b),y.x+=a[0]-b[0],y.y+=a[1]-b[1]}function g(b,c,d,g){b.__chart__={x:y.x,y:y.y,k:y.k},e(Math.pow(2,g)),f(q=c,d),b=ig.select(b),D>0&&(b=b.transition().duration(D)),b.call(a.event)}function h(){v&&v.domain(u.range().map(function(a){return(a-y.x)/y.k}).map(u.invert)),x&&x.domain(w.range().map(function(a){return(a-y.y)/y.k}).map(w.invert))}function i(a){E++||a({type:"zoomstart"})}function j(a){h(),a({type:"zoom",scale:y.k,translate:[y.x,y.y]})}function k(a){--E||(a({type:"zoomend"}),q=null)}function l(){function a(){h=1,f(ig.mouse(e),m),j(g)}function d(){l.on(G,null).on(H,null),n(h),k(g)}var e=this,g=J.of(e,arguments),h=0,l=ig.select(c(e)).on(G,a).on(H,d),m=b(ig.mouse(e)),n=Y(e);Mi.call(e),i(g)}function m(){function a(){var a=ig.touches(o);return n=y.k,a.forEach(function(a){a.identifier in q&&(q[a.identifier]=b(a))}),a}function c(){var b=ig.event.target;ig.select(b).on(u,d).on(v,h),w.push(b);for(var c=ig.event.changedTouches,e=0,f=c.length;e<f;++e)q[c[e].identifier]=null;var i=a(),j=Date.now();if(1===i.length){if(j-t<500){var k=i[0];g(o,k,q[k.identifier],Math.floor(Math.log(y.k)/Math.LN2)+1),z()}t=j}else if(i.length>1){var k=i[0],l=i[1],m=k[0]-l[0],n=k[1]-l[1];r=m*m+n*n}}function d(){var a,b,c,d,g=ig.touches(o);Mi.call(o);for(var h=0,i=g.length;h<i;++h,d=null)if(c=g[h],d=q[c.identifier]){if(b)break;a=c,b=d}if(d){var k=(k=c[0]-a[0])*k+(k=c[1]-a[1])*k,l=r&&Math.sqrt(k/r);a=[(a[0]+c[0])/2,(a[1]+c[1])/2],b=[(b[0]+d[0])/2,(b[1]+d[1])/2],e(l*n)}t=null,f(a,b),j(p)}function h(){if(ig.event.touches.length){for(var b=ig.event.changedTouches,c=0,d=b.length;c<d;++c)delete q[b[c].identifier];for(var e in q)return void a()}ig.selectAll(w).on(s,null),x.on(F,l).on(I,m),A(),k(p)}var n,o=this,p=J.of(o,arguments),q={},r=0,s=".zoom-"+ig.event.changedTouches[0].identifier,u="touchmove"+s,v="touchend"+s,w=[],x=ig.select(o),A=Y(o);c(),i(p),x.on(F,null).on(I,c)}function n(){var a=J.of(this,arguments);s?clearTimeout(s):(Mi.call(this),p=b(q=r||ig.mouse(this)),i(a)),s=setTimeout(function(){s=null,k(a)},50),z(),e(Math.pow(2,.002*Sg())*y.k),f(q,p),j(a)}function o(){var a=ig.mouse(this),c=Math.log(y.k)/Math.LN2;g(this,a,b(a),ig.event.shiftKey?Math.ceil(c)-1:Math.floor(c)+1)}var p,q,r,s,t,u,v,w,x,y={x:0,y:0,k:1},A=[960,500],C=Ug,D=250,E=0,F="mousedown.zoom",G="mousemove.zoom",H="mouseup.zoom",I="touchstart.zoom",J=B(a,"zoomstart","zoom","zoomend");return Tg||(Tg="onwheel"in lg?(Sg=function(){return-ig.event.deltaY*(ig.event.deltaMode?120:1)},"wheel"):"onmousewheel"in lg?(Sg=function(){return ig.event.wheelDelta},"mousewheel"):(Sg=function(){return-ig.event.detail},"MozMousePixelScroll")),a.event=function(a){a.each(function(){var a=J.of(this,arguments),b=y;Ki?ig.select(this).transition().each("start.zoom",function(){y=this.__chart__||{x:0,y:0,k:1},i(a)}).tween("zoom:zoom",function(){var c=A[0],d=A[1],e=q?q[0]:c/2,f=q?q[1]:d/2,g=ig.interpolateZoom([(e-y.x)/y.k,(f-y.y)/y.k,c/y.k],[(e-b.x)/b.k,(f-b.y)/b.k,c/b.k]);return function(b){var d=g(b),h=c/d[2];this.__chart__=y={x:e-d[0]*h,y:f-d[1]*h,k:h},j(a)}}).each("interrupt.zoom",function(){k(a)}).each("end.zoom",function(){k(a)}):(this.__chart__=y,i(a),j(a),k(a))})},a.translate=function(b){return arguments.length?(y={x:+b[0],y:+b[1],k:y.k},h(),a):[y.x,y.y]},a.scale=function(b){return arguments.length?(y={x:y.x,y:y.y,k:null},e(+b),h(),a):y.k},a.scaleExtent=function(b){return arguments.length?(C=null==b?Ug:[+b[0],+b[1]],a):C},a.center=function(b){return arguments.length?(r=b&&[+b[0],+b[1]],a):r},a.size=function(b){return arguments.length?(A=b&&[+b[0],+b[1]],a):A},a.duration=function(b){return arguments.length?(D=+b,a):D},a.x=function(b){return arguments.length?(v=b,u=b.copy(),y={x:0,y:0,k:1},a):v},a.y=function(b){return arguments.length?(x=b,w=b.copy(),y={x:0,y:0,k:1},a):x},ig.rebind(a,J,"on")};var Sg,Tg,Ug=[0,1/0];ig.color=ha,ha.prototype.toString=function(){return this.rgb()+""},ig.hsl=ia;var Vg=ia.prototype=new ha;Vg.brighter=function(a){return a=Math.pow(.7,arguments.length?a:1),new ia(this.h,this.s,this.l/a)},Vg.darker=function(a){return a=Math.pow(.7,arguments.length?a:1),new ia(this.h,this.s,a*this.l)},Vg.rgb=function(){return ja(this.h,this.s,this.l)},ig.hcl=ka;var Wg=ka.prototype=new ha;Wg.brighter=function(a){return new ka(this.h,this.c,Math.min(100,this.l+Xg*(arguments.length?a:1)))},Wg.darker=function(a){return new ka(this.h,this.c,Math.max(0,this.l-Xg*(arguments.length?a:1)))},Wg.rgb=function(){return la(this.h,this.c,this.l).rgb()},ig.lab=ma;var Xg=18,Yg=.95047,Zg=1,$g=1.08883,_g=ma.prototype=new ha;_g.brighter=function(a){return new ma(Math.min(100,this.l+Xg*(arguments.length?a:1)),this.a,this.b)},_g.darker=function(a){return new ma(Math.max(0,this.l-Xg*(arguments.length?a:1)),this.a,this.b)},_g.rgb=function(){return na(this.l,this.a,this.b)},ig.rgb=sa;var ah=sa.prototype=new ha;ah.brighter=function(a){a=Math.pow(.7,arguments.length?a:1);var b=this.r,c=this.g,d=this.b,e=30;return b||c||d?(b&&b<e&&(b=e),c&&c<e&&(c=e),d&&d<e&&(d=e),new sa(Math.min(255,b/a),Math.min(255,c/a),Math.min(255,d/a))):new sa(e,e,e)},ah.darker=function(a){return a=Math.pow(.7,arguments.length?a:1),new sa(a*this.r,a*this.g,a*this.b)},ah.hsl=function(){return xa(this.r,this.g,this.b)},ah.toString=function(){return"#"+va(this.r)+va(this.g)+va(this.b)};var bh=ig.map({aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,
+white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074});bh.forEach(function(a,b){bh.set(a,ta(b))}),ig.functor=Ba,ig.xhr=Ca(t),ig.dsv=function(a,b){function c(a,c,f){arguments.length<3&&(f=c,c=null);var g=Da(a,b,null==c?d:e(c),f);return g.row=function(a){return arguments.length?g.response(null==(c=a)?d:e(a)):c},g}function d(a){return c.parse(a.responseText)}function e(a){return function(b){return c.parse(b.responseText,a)}}function f(b){return b.map(g).join(a)}function g(a){return h.test(a)?'"'+a.replace(/\"/g,'""')+'"':a}var h=new RegExp('["'+a+"\n]"),i=a.charCodeAt(0);return c.parse=function(a,b){var d;return c.parseRows(a,function(a,c){if(d)return d(a,c-1);var e=new Function("d","return {"+a.map(function(a,b){return JSON.stringify(a)+": d["+b+"]"}).join(",")+"}");d=b?function(a,c){return b(e(a),c)}:e})},c.parseRows=function(a,b){function c(){if(k>=j)return g;if(e)return e=!1,f;var b=k;if(34===a.charCodeAt(b)){for(var c=b;c++<j;)if(34===a.charCodeAt(c)){if(34!==a.charCodeAt(c+1))break;++c}k=c+2;var d=a.charCodeAt(c+1);return 13===d?(e=!0,10===a.charCodeAt(c+2)&&++k):10===d&&(e=!0),a.slice(b+1,c).replace(/""/g,'"')}for(;k<j;){var d=a.charCodeAt(k++),h=1;if(10===d)e=!0;else if(13===d)e=!0,10===a.charCodeAt(k)&&(++k,++h);else if(d!==i)continue;return a.slice(b,k-h)}return a.slice(b)}for(var d,e,f={},g={},h=[],j=a.length,k=0,l=0;(d=c())!==g;){for(var m=[];d!==f&&d!==g;)m.push(d),d=c();b&&null==(m=b(m,l++))||h.push(m)}return h},c.format=function(b){if(Array.isArray(b[0]))return c.formatRows(b);var d=new s,e=[];return b.forEach(function(a){for(var b in a)d.has(b)||e.push(d.add(b))}),[e.map(g).join(a)].concat(b.map(function(b){return e.map(function(a){return g(b[a])}).join(a)})).join("\n")},c.formatRows=function(a){return a.map(f).join("\n")},c},ig.csv=ig.dsv(",","text/csv"),ig.tsv=ig.dsv("\t","text/tab-separated-values");var ch,dh,eh,fh,gh=this[v(this,"requestAnimationFrame")]||function(a){setTimeout(a,17)};ig.timer=function(){Ga.apply(this,arguments)},ig.timer.flush=function(){Ia(),Ja()},ig.round=function(a,b){return b?Math.round(a*(b=Math.pow(10,b)))/b:Math.round(a)};var hh=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"].map(La);ig.formatPrefix=function(a,b){var c=0;return(a=+a)&&(a<0&&(a*=-1),b&&(a=ig.round(a,Ka(a,b))),c=1+Math.floor(1e-12+Math.log(a)/Math.LN10),c=Math.max(-24,Math.min(24,3*Math.floor((c-1)/3)))),hh[8+c/3]};var ih=/(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i,jh=ig.map({b:function(a){return a.toString(2)},c:function(a){return String.fromCharCode(a)},o:function(a){return a.toString(8)},x:function(a){return a.toString(16)},X:function(a){return a.toString(16).toUpperCase()},g:function(a,b){return a.toPrecision(b)},e:function(a,b){return a.toExponential(b)},f:function(a,b){return a.toFixed(b)},r:function(a,b){return(a=ig.round(a,Ka(a,b))).toFixed(Math.max(0,Math.min(20,Ka(a*(1+1e-15),b))))}}),kh=ig.time={},lh=Date;Oa.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTime:function(){return this._.getTime()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.valueOf()},setDate:function(){mh.setUTCDate.apply(this._,arguments)},setDay:function(){mh.setUTCDay.apply(this._,arguments)},setFullYear:function(){mh.setUTCFullYear.apply(this._,arguments)},setHours:function(){mh.setUTCHours.apply(this._,arguments)},setMilliseconds:function(){mh.setUTCMilliseconds.apply(this._,arguments)},setMinutes:function(){mh.setUTCMinutes.apply(this._,arguments)},setMonth:function(){mh.setUTCMonth.apply(this._,arguments)},setSeconds:function(){mh.setUTCSeconds.apply(this._,arguments)},setTime:function(){mh.setTime.apply(this._,arguments)}};var mh=Date.prototype;kh.year=Pa(function(a){return a=kh.day(a),a.setMonth(0,1),a},function(a,b){a.setFullYear(a.getFullYear()+b)},function(a){return a.getFullYear()}),kh.years=kh.year.range,kh.years.utc=kh.year.utc.range,kh.day=Pa(function(a){var b=new lh(2e3,0);return b.setFullYear(a.getFullYear(),a.getMonth(),a.getDate()),b},function(a,b){a.setDate(a.getDate()+b)},function(a){return a.getDate()-1}),kh.days=kh.day.range,kh.days.utc=kh.day.utc.range,kh.dayOfYear=function(a){var b=kh.year(a);return Math.floor((a-b-6e4*(a.getTimezoneOffset()-b.getTimezoneOffset()))/864e5)},["sunday","monday","tuesday","wednesday","thursday","friday","saturday"].forEach(function(a,b){b=7-b;var c=kh[a]=Pa(function(a){return(a=kh.day(a)).setDate(a.getDate()-(a.getDay()+b)%7),a},function(a,b){a.setDate(a.getDate()+7*Math.floor(b))},function(a){var c=kh.year(a).getDay();return Math.floor((kh.dayOfYear(a)+(c+b)%7)/7)-(c!==b)});kh[a+"s"]=c.range,kh[a+"s"].utc=c.utc.range,kh[a+"OfYear"]=function(a){var c=kh.year(a).getDay();return Math.floor((kh.dayOfYear(a)+(c+b)%7)/7)}}),kh.week=kh.sunday,kh.weeks=kh.sunday.range,kh.weeks.utc=kh.sunday.utc.range,kh.weekOfYear=kh.sundayOfYear;var nh={"-":"",_:" ",0:"0"},oh=/^\s*\d+/,ph=/^%/;ig.locale=function(a){return{numberFormat:Ma(a),timeFormat:Ra(a)}};var qh=ig.locale({decimal:".",thousands:",",grouping:[3],currency:["$",""],dateTime:"%a %b %e %X %Y",date:"%m/%d/%Y",time:"%H:%M:%S",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});ig.format=qh.numberFormat,ig.geo={},kb.prototype={s:0,t:0,add:function(a){lb(a,this.t,rh),lb(rh.s,this.s,this),this.s?this.t+=rh.t:this.s=rh.t},reset:function(){this.s=this.t=0},valueOf:function(){return this.s}};var rh=new kb;ig.geo.stream=function(a,b){a&&sh.hasOwnProperty(a.type)?sh[a.type](a,b):mb(a,b)};var sh={Feature:function(a,b){mb(a.geometry,b)},FeatureCollection:function(a,b){for(var c=a.features,d=-1,e=c.length;++d<e;)mb(c[d].geometry,b)}},th={Sphere:function(a,b){b.sphere()},Point:function(a,b){a=a.coordinates,b.point(a[0],a[1],a[2])},MultiPoint:function(a,b){for(var c=a.coordinates,d=-1,e=c.length;++d<e;)a=c[d],b.point(a[0],a[1],a[2])},LineString:function(a,b){nb(a.coordinates,b,0)},MultiLineString:function(a,b){for(var c=a.coordinates,d=-1,e=c.length;++d<e;)nb(c[d],b,0)},Polygon:function(a,b){ob(a.coordinates,b)},MultiPolygon:function(a,b){for(var c=a.coordinates,d=-1,e=c.length;++d<e;)ob(c[d],b)},GeometryCollection:function(a,b){for(var c=a.geometries,d=-1,e=c.length;++d<e;)mb(c[d],b)}};ig.geo.area=function(a){return uh=0,ig.geo.stream(a,wh),uh};var uh,vh=new kb,wh={sphere:function(){uh+=4*Lg},point:w,lineStart:w,lineEnd:w,polygonStart:function(){vh.reset(),wh.lineStart=pb},polygonEnd:function(){var a=2*vh;uh+=a<0?4*Lg+a:a,wh.lineStart=wh.lineEnd=wh.point=w}};ig.geo.bounds=function(){function a(a,b){t.push(u=[k=a,m=a]),b<l&&(l=b),b>n&&(n=b)}function b(b,c){var d=qb([b*Pg,c*Pg]);if(r){var e=sb(r,d),f=[e[1],-e[0],0],g=sb(f,e);vb(g),g=wb(g);var i=b-o,j=i>0?1:-1,p=g[0]*Qg*j,q=sg(i)>180;if(q^(j*o<p&&p<j*b)){var s=g[1]*Qg;s>n&&(n=s)}else if(p=(p+360)%360-180,q^(j*o<p&&p<j*b)){var s=-g[1]*Qg;s<l&&(l=s)}else c<l&&(l=c),c>n&&(n=c);q?b<o?h(k,b)>h(k,m)&&(m=b):h(b,m)>h(k,m)&&(k=b):m>=k?(b<k&&(k=b),b>m&&(m=b)):b>o?h(k,b)>h(k,m)&&(m=b):h(b,m)>h(k,m)&&(k=b)}else a(b,c);r=d,o=b}function c(){v.point=b}function d(){u[0]=k,u[1]=m,v.point=a,r=null}function e(a,c){if(r){var d=a-o;s+=sg(d)>180?d+(d>0?360:-360):d}else p=a,q=c;wh.point(a,c),b(a,c)}function f(){wh.lineStart()}function g(){e(p,q),wh.lineEnd(),sg(s)>Jg&&(k=-(m=180)),u[0]=k,u[1]=m,r=null}function h(a,b){return(b-=a)<0?b+360:b}function i(a,b){return a[0]-b[0]}function j(a,b){return b[0]<=b[1]?b[0]<=a&&a<=b[1]:a<b[0]||b[1]<a}var k,l,m,n,o,p,q,r,s,t,u,v={point:a,lineStart:c,lineEnd:d,polygonStart:function(){v.point=e,v.lineStart=f,v.lineEnd=g,s=0,wh.polygonStart()},polygonEnd:function(){wh.polygonEnd(),v.point=a,v.lineStart=c,v.lineEnd=d,vh<0?(k=-(m=180),l=-(n=90)):s>Jg?n=90:s<-Jg&&(l=-90),u[0]=k,u[1]=m}};return function(a){n=m=-(k=l=1/0),t=[],ig.geo.stream(a,v);var b=t.length;if(b){t.sort(i);for(var c,d=1,e=t[0],f=[e];d<b;++d)c=t[d],j(c[0],e)||j(c[1],e)?(h(e[0],c[1])>h(e[0],e[1])&&(e[1]=c[1]),h(c[0],e[1])>h(e[0],e[1])&&(e[0]=c[0])):f.push(e=c);for(var g,c,o=-(1/0),b=f.length-1,d=0,e=f[b];d<=b;e=c,++d)c=f[d],(g=h(e[1],c[0]))>o&&(o=g,k=c[0],m=e[1])}return t=u=null,k===1/0||l===1/0?[[NaN,NaN],[NaN,NaN]]:[[k,l],[m,n]]}}(),ig.geo.centroid=function(a){xh=yh=zh=Ah=Bh=Ch=Dh=Eh=Fh=Gh=Hh=0,ig.geo.stream(a,Ih);var b=Fh,c=Gh,d=Hh,e=b*b+c*c+d*d;return e<Kg&&(b=Ch,c=Dh,d=Eh,yh<Jg&&(b=zh,c=Ah,d=Bh),(e=b*b+c*c+d*d)<Kg)?[NaN,NaN]:[Math.atan2(c,b)*Qg,ca(d/Math.sqrt(e))*Qg]};var xh,yh,zh,Ah,Bh,Ch,Dh,Eh,Fh,Gh,Hh,Ih={sphere:w,point:yb,lineStart:Ab,lineEnd:Bb,polygonStart:function(){Ih.lineStart=Cb},polygonEnd:function(){Ih.lineStart=Ab}},Jh=Ib(Eb,Mb,Ob,[-Lg,-Lg/2]),Kh=1e9;ig.geo.clipExtent=function(){var a,b,c,d,e,f,g={stream:function(a){return e&&(e.valid=!1),e=f(a),e.valid=!0,e},extent:function(h){return arguments.length?(f=Sb(a=+h[0][0],b=+h[0][1],c=+h[1][0],d=+h[1][1]),e&&(e.valid=!1,e=null),g):[[a,b],[c,d]]}};return g.extent([[0,0],[960,500]])},(ig.geo.conicEqualArea=function(){return Tb(Ub)}).raw=Ub,ig.geo.albers=function(){return ig.geo.conicEqualArea().rotate([96,0]).center([-.6,38.7]).parallels([29.5,45.5]).scale(1070)},ig.geo.albersUsa=function(){function a(a){var f=a[0],g=a[1];return b=null,c(f,g),b||(d(f,g),b)||e(f,g),b}var b,c,d,e,f=ig.geo.albers(),g=ig.geo.conicEqualArea().rotate([154,0]).center([-2,58.5]).parallels([55,65]),h=ig.geo.conicEqualArea().rotate([157,0]).center([-3,19.9]).parallels([8,18]),i={point:function(a,c){b=[a,c]}};return a.invert=function(a){var b=f.scale(),c=f.translate(),d=(a[0]-c[0])/b,e=(a[1]-c[1])/b;return(e>=.12&&e<.234&&d>=-.425&&d<-.214?g:e>=.166&&e<.234&&d>=-.214&&d<-.115?h:f).invert(a)},a.stream=function(a){var b=f.stream(a),c=g.stream(a),d=h.stream(a);return{point:function(a,e){b.point(a,e),c.point(a,e),d.point(a,e)},sphere:function(){b.sphere(),c.sphere(),d.sphere()},lineStart:function(){b.lineStart(),c.lineStart(),d.lineStart()},lineEnd:function(){b.lineEnd(),c.lineEnd(),d.lineEnd()},polygonStart:function(){b.polygonStart(),c.polygonStart(),d.polygonStart()},polygonEnd:function(){b.polygonEnd(),c.polygonEnd(),d.polygonEnd()}}},a.precision=function(b){return arguments.length?(f.precision(b),g.precision(b),h.precision(b),a):f.precision()},a.scale=function(b){return arguments.length?(f.scale(b),g.scale(.35*b),h.scale(b),a.translate(f.translate())):f.scale()},a.translate=function(b){if(!arguments.length)return f.translate();var j=f.scale(),k=+b[0],l=+b[1];return c=f.translate(b).clipExtent([[k-.455*j,l-.238*j],[k+.455*j,l+.238*j]]).stream(i).point,d=g.translate([k-.307*j,l+.201*j]).clipExtent([[k-.425*j+Jg,l+.12*j+Jg],[k-.214*j-Jg,l+.234*j-Jg]]).stream(i).point,e=h.translate([k-.205*j,l+.212*j]).clipExtent([[k-.214*j+Jg,l+.166*j+Jg],[k-.115*j-Jg,l+.234*j-Jg]]).stream(i).point,a},a.scale(1070)};var Lh,Mh,Nh,Oh,Ph,Qh,Rh={point:w,lineStart:w,lineEnd:w,polygonStart:function(){Mh=0,Rh.lineStart=Vb},polygonEnd:function(){Rh.lineStart=Rh.lineEnd=Rh.point=w,Lh+=sg(Mh/2)}},Sh={point:Wb,lineStart:w,lineEnd:w,polygonStart:w,polygonEnd:w},Th={point:Zb,lineStart:$b,lineEnd:_b,polygonStart:function(){Th.lineStart=ac},polygonEnd:function(){Th.point=Zb,Th.lineStart=$b,Th.lineEnd=_b}};ig.geo.path=function(){function a(a){return a&&("function"==typeof h&&f.pointRadius(+h.apply(this,arguments)),g&&g.valid||(g=e(f)),ig.geo.stream(a,g)),f.result()}function b(){return g=null,a}var c,d,e,f,g,h=4.5;return a.area=function(a){return Lh=0,ig.geo.stream(a,e(Rh)),Lh},a.centroid=function(a){return zh=Ah=Bh=Ch=Dh=Eh=Fh=Gh=Hh=0,ig.geo.stream(a,e(Th)),Hh?[Fh/Hh,Gh/Hh]:Eh?[Ch/Eh,Dh/Eh]:Bh?[zh/Bh,Ah/Bh]:[NaN,NaN]},a.bounds=function(a){return Ph=Qh=-(Nh=Oh=1/0),ig.geo.stream(a,e(Sh)),[[Nh,Oh],[Ph,Qh]]},a.projection=function(a){return arguments.length?(e=(c=a)?a.stream||dc(a):t,b()):c},a.context=function(a){return arguments.length?(f=null==(d=a)?new Xb:new bc(a),"function"!=typeof h&&f.pointRadius(h),b()):d},a.pointRadius=function(b){return arguments.length?(h="function"==typeof b?b:(f.pointRadius(+b),+b),a):h},a.projection(ig.geo.albersUsa()).context(null)},ig.geo.transform=function(a){return{stream:function(b){var c=new ec(b);for(var d in a)c[d]=a[d];return c}}},ec.prototype={point:function(a,b){this.stream.point(a,b)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}},ig.geo.projection=gc,ig.geo.projectionMutator=hc,(ig.geo.equirectangular=function(){return gc(jc)}).raw=jc.invert=jc,ig.geo.rotation=function(a){function b(b){return b=a(b[0]*Pg,b[1]*Pg),b[0]*=Qg,b[1]*=Qg,b}return a=lc(a[0]%360*Pg,a[1]*Pg,a.length>2?a[2]*Pg:0),b.invert=function(b){return b=a.invert(b[0]*Pg,b[1]*Pg),b[0]*=Qg,b[1]*=Qg,b},b},kc.invert=jc,ig.geo.circle=function(){function a(){var a="function"==typeof d?d.apply(this,arguments):d,b=lc(-a[0]*Pg,-a[1]*Pg,0).invert,e=[];return c(null,null,1,{point:function(a,c){e.push(a=b(a,c)),a[0]*=Qg,a[1]*=Qg}}),{type:"Polygon",coordinates:[e]}}var b,c,d=[0,0],e=6;return a.origin=function(b){return arguments.length?(d=b,a):d},a.angle=function(d){return arguments.length?(c=pc((b=+d)*Pg,e*Pg),a):b},a.precision=function(d){return arguments.length?(c=pc(b*Pg,(e=+d)*Pg),a):e},a.angle(90)},ig.geo.distance=function(a,b){var c,d=(b[0]-a[0])*Pg,e=a[1]*Pg,f=b[1]*Pg,g=Math.sin(d),h=Math.cos(d),i=Math.sin(e),j=Math.cos(e),k=Math.sin(f),l=Math.cos(f);return Math.atan2(Math.sqrt((c=l*g)*c+(c=j*k-i*l*h)*c),i*k+j*l*h)},ig.geo.graticule=function(){function a(){return{type:"MultiLineString",coordinates:b()}}function b(){return ig.range(Math.ceil(f/q)*q,e,q).map(m).concat(ig.range(Math.ceil(j/r)*r,i,r).map(n)).concat(ig.range(Math.ceil(d/o)*o,c,o).filter(function(a){return sg(a%q)>Jg}).map(k)).concat(ig.range(Math.ceil(h/p)*p,g,p).filter(function(a){return sg(a%r)>Jg}).map(l))}var c,d,e,f,g,h,i,j,k,l,m,n,o=10,p=o,q=90,r=360,s=2.5;return a.lines=function(){return b().map(function(a){return{type:"LineString",coordinates:a}})},a.outline=function(){return{type:"Polygon",coordinates:[m(f).concat(n(i).slice(1),m(e).reverse().slice(1),n(j).reverse().slice(1))]}},a.extent=function(b){return arguments.length?a.majorExtent(b).minorExtent(b):a.minorExtent()},a.majorExtent=function(b){return arguments.length?(f=+b[0][0],e=+b[1][0],j=+b[0][1],i=+b[1][1],f>e&&(b=f,f=e,e=b),j>i&&(b=j,j=i,i=b),a.precision(s)):[[f,j],[e,i]]},a.minorExtent=function(b){return arguments.length?(d=+b[0][0],c=+b[1][0],h=+b[0][1],g=+b[1][1],d>c&&(b=d,d=c,c=b),h>g&&(b=h,h=g,g=b),a.precision(s)):[[d,h],[c,g]]},a.step=function(b){return arguments.length?a.majorStep(b).minorStep(b):a.minorStep()},a.majorStep=function(b){return arguments.length?(q=+b[0],r=+b[1],a):[q,r]},a.minorStep=function(b){return arguments.length?(o=+b[0],p=+b[1],a):[o,p]},a.precision=function(b){return arguments.length?(s=+b,k=rc(h,g,90),l=sc(d,c,s),m=rc(j,i,90),n=sc(f,e,s),a):s},a.majorExtent([[-180,-90+Jg],[180,90-Jg]]).minorExtent([[-180,-80-Jg],[180,80+Jg]])},ig.geo.greatArc=function(){function a(){return{type:"LineString",coordinates:[b||d.apply(this,arguments),c||e.apply(this,arguments)]}}var b,c,d=tc,e=uc;return a.distance=function(){return ig.geo.distance(b||d.apply(this,arguments),c||e.apply(this,arguments))},a.source=function(c){return arguments.length?(d=c,b="function"==typeof c?null:c,a):d},a.target=function(b){return arguments.length?(e=b,c="function"==typeof b?null:b,a):e},a.precision=function(){return arguments.length?a:0},a},ig.geo.interpolate=function(a,b){return vc(a[0]*Pg,a[1]*Pg,b[0]*Pg,b[1]*Pg)},ig.geo.length=function(a){return Uh=0,ig.geo.stream(a,Vh),Uh};var Uh,Vh={sphere:w,point:w,lineStart:wc,lineEnd:w,polygonStart:w,polygonEnd:w},Wh=xc(function(a){return Math.sqrt(2/(1+a))},function(a){return 2*Math.asin(a/2)});(ig.geo.azimuthalEqualArea=function(){return gc(Wh)}).raw=Wh;var Xh=xc(function(a){var b=Math.acos(a);return b&&b/Math.sin(b)},t);(ig.geo.azimuthalEquidistant=function(){return gc(Xh)}).raw=Xh,(ig.geo.conicConformal=function(){return Tb(yc)}).raw=yc,(ig.geo.conicEquidistant=function(){return Tb(zc)}).raw=zc;var Yh=xc(function(a){return 1/a},Math.atan);(ig.geo.gnomonic=function(){return gc(Yh)}).raw=Yh,Ac.invert=function(a,b){return[a,2*Math.atan(Math.exp(b))-Og]},(ig.geo.mercator=function(){return Bc(Ac)}).raw=Ac;var Zh=xc(function(){return 1},Math.asin);(ig.geo.orthographic=function(){return gc(Zh)}).raw=Zh;var $h=xc(function(a){return 1/(1+a)},function(a){return 2*Math.atan(a)});(ig.geo.stereographic=function(){return gc($h)}).raw=$h,Cc.invert=function(a,b){return[-b,2*Math.atan(Math.exp(a))-Og]},(ig.geo.transverseMercator=function(){var a=Bc(Cc),b=a.center,c=a.rotate;return a.center=function(a){return a?b([-a[1],a[0]]):(a=b(),[a[1],-a[0]])},a.rotate=function(a){return a?c([a[0],a[1],a.length>2?a[2]+90:90]):(a=c(),[a[0],a[1],a[2]-90])},c([0,0,90])}).raw=Cc,ig.geom={},ig.geom.hull=function(a){function b(a){if(a.length<3)return[];var b,e=Ba(c),f=Ba(d),g=a.length,h=[],i=[];for(b=0;b<g;b++)h.push([+e.call(this,a[b],b),+f.call(this,a[b],b),b]);for(h.sort(Gc),b=0;b<g;b++)i.push([h[b][0],-h[b][1]]);var j=Fc(h),k=Fc(i),l=k[0]===j[0],m=k[k.length-1]===j[j.length-1],n=[];for(b=j.length-1;b>=0;--b)n.push(a[h[j[b]][2]]);for(b=+l;b<k.length-m;++b)n.push(a[h[k[b]][2]]);return n}var c=Dc,d=Ec;return arguments.length?b(a):(b.x=function(a){return arguments.length?(c=a,b):c},b.y=function(a){return arguments.length?(d=a,b):d},b)},ig.geom.polygon=function(a){return xg(a,_h),a};var _h=ig.geom.polygon.prototype=[];_h.area=function(){for(var a,b=-1,c=this.length,d=this[c-1],e=0;++b<c;)a=d,d=this[b],e+=a[1]*d[0]-a[0]*d[1];return.5*e},_h.centroid=function(a){var b,c,d=-1,e=this.length,f=0,g=0,h=this[e-1];for(arguments.length||(a=-1/(6*this.area()));++d<e;)b=h,h=this[d],c=b[0]*h[1]-h[0]*b[1],f+=(b[0]+h[0])*c,g+=(b[1]+h[1])*c;return[f*a,g*a]},_h.clip=function(a){for(var b,c,d,e,f,g,h=Jc(a),i=-1,j=this.length-Jc(this),k=this[j-1];++i<j;){for(b=a.slice(),a.length=0,e=this[i],f=b[(d=b.length-h)-1],c=-1;++c<d;)g=b[c],Hc(g,k,e)?(Hc(f,k,e)||a.push(Ic(f,g,k,e)),a.push(g)):Hc(f,k,e)&&a.push(Ic(f,g,k,e)),f=g;h&&a.push(a[0]),k=e}return a};var ai,bi,ci,di,ei,fi=[],gi=[];Rc.prototype.prepare=function(){for(var a,b=this.edges,c=b.length;c--;)a=b[c].edge,a.b&&a.a||b.splice(c,1);return b.sort(Tc),b.length},bd.prototype={start:function(){return this.edge.l===this.site?this.edge.a:this.edge.b},end:function(){return this.edge.l===this.site?this.edge.b:this.edge.a}},cd.prototype={insert:function(a,b){var c,d,e;if(a){if(b.P=a,b.N=a.N,a.N&&(a.N.P=b),a.N=b,a.R){for(a=a.R;a.L;)a=a.L;a.L=b}else a.R=b;c=a}else this._?(a=gd(this._),b.P=null,b.N=a,a.P=a.L=b,c=a):(b.P=b.N=null,this._=b,c=null);for(b.L=b.R=null,b.U=c,b.C=!0,a=b;c&&c.C;)d=c.U,c===d.L?(e=d.R,e&&e.C?(c.C=e.C=!1,d.C=!0,a=d):(a===c.R&&(ed(this,c),a=c,c=a.U),c.C=!1,d.C=!0,fd(this,d))):(e=d.L,e&&e.C?(c.C=e.C=!1,d.C=!0,a=d):(a===c.L&&(fd(this,c),a=c,c=a.U),c.C=!1,d.C=!0,ed(this,d))),c=a.U;this._.C=!1},remove:function(a){a.N&&(a.N.P=a.P),a.P&&(a.P.N=a.N),a.N=a.P=null;var b,c,d,e=a.U,f=a.L,g=a.R;if(c=f?g?gd(g):f:g,e?e.L===a?e.L=c:e.R=c:this._=c,f&&g?(d=c.C,c.C=a.C,c.L=f,f.U=c,c!==g?(e=c.U,c.U=a.U,a=c.R,e.L=a,c.R=g,g.U=c):(c.U=e,e=c,a=c.R)):(d=a.C,a=c),a&&(a.U=e),!d){if(a&&a.C)return void(a.C=!1);do{if(a===this._)break;if(a===e.L){if(b=e.R,b.C&&(b.C=!1,e.C=!0,ed(this,e),b=e.R),b.L&&b.L.C||b.R&&b.R.C){b.R&&b.R.C||(b.L.C=!1,b.C=!0,fd(this,b),b=e.R),b.C=e.C,e.C=b.R.C=!1,ed(this,e),a=this._;break}}else if(b=e.L,b.C&&(b.C=!1,e.C=!0,fd(this,e),b=e.L),b.L&&b.L.C||b.R&&b.R.C){b.L&&b.L.C||(b.R.C=!1,b.C=!0,ed(this,b),b=e.L),b.C=e.C,e.C=b.L.C=!1,fd(this,e),a=this._;break}b.C=!0,a=e,e=e.U}while(!a.C);a&&(a.C=!1)}}},ig.geom.voronoi=function(a){function b(a){var b=new Array(a.length),d=h[0][0],e=h[0][1],f=h[1][0],g=h[1][1];return hd(c(a),h).cells.forEach(function(c,h){var i=c.edges,j=c.site;(b[h]=i.length?i.map(function(a){var b=a.start();return[b.x,b.y]}):j.x>=d&&j.x<=f&&j.y>=e&&j.y<=g?[[d,g],[f,g],[f,e],[d,e]]:[]).point=a[h]}),b}function c(a){return a.map(function(a,b){return{x:Math.round(f(a,b)/Jg)*Jg,y:Math.round(g(a,b)/Jg)*Jg,i:b}})}var d=Dc,e=Ec,f=d,g=e,h=hi;return a?b(a):(b.links=function(a){return hd(c(a)).edges.filter(function(a){return a.l&&a.r}).map(function(b){return{source:a[b.l.i],target:a[b.r.i]}})},b.triangles=function(a){var b=[];return hd(c(a)).cells.forEach(function(c,d){for(var e,f=c.site,g=c.edges.sort(Tc),h=-1,i=g.length,j=g[i-1].edge,k=j.l===f?j.r:j.l;++h<i;)j,e=k,j=g[h].edge,k=j.l===f?j.r:j.l,d<e.i&&d<k.i&&jd(f,e,k)<0&&b.push([a[d],a[e.i],a[k.i]])}),b},b.x=function(a){return arguments.length?(f=Ba(d=a),b):d},b.y=function(a){return arguments.length?(g=Ba(e=a),b):e},b.clipExtent=function(a){return arguments.length?(h=null==a?hi:a,b):h===hi?null:h},b.size=function(a){return arguments.length?b.clipExtent(a&&[[0,0],a]):h===hi?null:h&&h[1]},b)};var hi=[[-1e6,-1e6],[1e6,1e6]];ig.geom.delaunay=function(a){return ig.geom.voronoi().triangles(a)},ig.geom.quadtree=function(a,b,c,d,e){function f(a){function f(a,b,c,d,e,f,g,h){if(!isNaN(c)&&!isNaN(d))if(a.leaf){var i=a.x,k=a.y;if(null!=i)if(sg(i-c)+sg(k-d)<.01)j(a,b,c,d,e,f,g,h);else{var l=a.point;a.x=a.y=a.point=null,j(a,l,i,k,e,f,g,h),j(a,b,c,d,e,f,g,h)}else a.x=c,a.y=d,a.point=b}else j(a,b,c,d,e,f,g,h)}function j(a,b,c,d,e,g,h,i){var j=.5*(e+h),k=.5*(g+i),l=c>=j,m=d>=k,n=m<<1|l;a.leaf=!1,a=a.nodes[n]||(a.nodes[n]=md()),l?e=j:h=j,m?g=k:i=k,f(a,b,c,d,e,g,h,i)}var k,l,m,n,o,p,q,r,s,t=Ba(h),u=Ba(i);if(null!=b)p=b,q=c,r=d,s=e;else if(r=s=-(p=q=1/0),l=[],m=[],o=a.length,g)for(n=0;n<o;++n)k=a[n],k.x<p&&(p=k.x),k.y<q&&(q=k.y),k.x>r&&(r=k.x),k.y>s&&(s=k.y),l.push(k.x),m.push(k.y);else for(n=0;n<o;++n){var v=+t(k=a[n],n),w=+u(k,n);v<p&&(p=v),w<q&&(q=w),v>r&&(r=v),w>s&&(s=w),l.push(v),m.push(w)}var x=r-p,y=s-q;x>y?s=q+x:r=p+y;var z=md();if(z.add=function(a){f(z,a,+t(a,++n),+u(a,n),p,q,r,s)},z.visit=function(a){nd(a,z,p,q,r,s)},z.find=function(a){return od(z,a[0],a[1],p,q,r,s)},n=-1,null==b){for(;++n<o;)f(z,a[n],l[n],m[n],p,q,r,s);--n}else a.forEach(z.add);return l=m=a=k=null,z}var g,h=Dc,i=Ec;return(g=arguments.length)?(h=kd,i=ld,3===g&&(e=c,d=b,c=b=0),f(a)):(f.x=function(a){return arguments.length?(h=a,f):h},f.y=function(a){return arguments.length?(i=a,f):i},f.extent=function(a){return arguments.length?(null==a?b=c=d=e=null:(b=+a[0][0],c=+a[0][1],d=+a[1][0],e=+a[1][1]),f):null==b?null:[[b,c],[d,e]]},f.size=function(a){return arguments.length?(null==a?b=c=d=e=null:(b=c=0,d=+a[0],e=+a[1]),f):null==b?null:[d-b,e-c]},f)},ig.interpolateRgb=pd,ig.interpolateObject=qd,ig.interpolateNumber=rd,ig.interpolateString=sd;var ii=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,ji=new RegExp(ii.source,"g");ig.interpolate=td,ig.interpolators=[function(a,b){var c=typeof b;return("string"===c?bh.has(b.toLowerCase())||/^(#|rgb\(|hsl\()/i.test(b)?pd:sd:b instanceof ha?pd:Array.isArray(b)?ud:"object"===c&&isNaN(b)?qd:rd)(a,b)}],ig.interpolateArray=ud;var ki=function(){return t},li=ig.map({linear:ki,poly:Bd,quad:function(){return yd},cubic:function(){return zd},sin:function(){return Cd},exp:function(){return Dd},circle:function(){return Ed},elastic:Fd,back:Gd,bounce:function(){return Hd}}),mi=ig.map({in:t,out:wd,"in-out":xd,"out-in":function(a){return xd(wd(a))}});ig.ease=function(a){var b=a.indexOf("-"),c=b>=0?a.slice(0,b):a,d=b>=0?a.slice(b+1):"in";return c=li.get(c)||ki,d=mi.get(d)||t,vd(d(c.apply(null,jg.call(arguments,1))))},ig.interpolateHcl=Id,ig.interpolateHsl=Jd,ig.interpolateLab=Kd,ig.interpolateRound=Ld,ig.transform=function(a){var b=lg.createElementNS(ig.ns.prefix.svg,"g");return(ig.transform=function(a){if(null!=a){b.setAttribute("transform",a);var c=b.transform.baseVal.consolidate()}return new Md(c?c.matrix:ni)})(a)},Md.prototype.toString=function(){return"translate("+this.translate+")rotate("+this.rotate+")skewX("+this.skew+")scale("+this.scale+")"};var ni={a:1,b:0,c:0,d:1,e:0,f:0};ig.interpolateTransform=Vd,ig.layout={},ig.layout.bundle=function(){return function(a){for(var b=[],c=-1,d=a.length;++c<d;)b.push(Yd(a[c]));return b}},ig.layout.chord=function(){function a(){var a,j,l,m,n,o={},p=[],q=ig.range(f),r=[];for(c=[],d=[],a=0,m=-1;++m<f;){for(j=0,n=-1;++n<f;)j+=e[m][n];p.push(j),r.push(ig.range(f)),a+=j}for(g&&q.sort(function(a,b){return g(p[a],p[b])}),h&&r.forEach(function(a,b){a.sort(function(a,c){return h(e[b][a],e[b][c])})}),a=(Mg-k*f)/a,j=0,m=-1;++m<f;){for(l=j,n=-1;++n<f;){var s=q[m],t=r[s][n],u=e[s][t],v=j,w=j+=u*a;o[s+"-"+t]={index:s,subindex:t,startAngle:v,endAngle:w,value:u}}d[s]={index:s,startAngle:l,endAngle:j,value:p[s]},j+=k}for(m=-1;++m<f;)for(n=m-1;++n<f;){var x=o[m+"-"+n],y=o[n+"-"+m];(x.value||y.value)&&c.push(x.value<y.value?{source:y,target:x}:{source:x,target:y})}i&&b()}function b(){c.sort(function(a,b){return i((a.source.value+a.target.value)/2,(b.source.value+b.target.value)/2)})}var c,d,e,f,g,h,i,j={},k=0;return j.matrix=function(a){return arguments.length?(f=(e=a)&&e.length,c=d=null,j):e},j.padding=function(a){return arguments.length?(k=a,c=d=null,j):k},j.sortGroups=function(a){return arguments.length?(g=a,c=d=null,j):g},j.sortSubgroups=function(a){return arguments.length?(h=a,c=null,j):h},j.sortChords=function(a){return arguments.length?(i=a,c&&b(),j):i},j.chords=function(){return c||a(),c},j.groups=function(){return d||a(),d},j},ig.layout.force=function(){function a(a){return function(b,c,d,e){if(b.point!==a){var f=b.cx-a.x,g=b.cy-a.y,h=e-c,i=f*f+g*g;if(h*h/r<i){if(i<p){var j=b.charge/i;a.px-=f*j,a.py-=g*j}return!0}if(b.point&&i&&i<p){var j=b.pointCharge/i;a.px-=f*j,a.py-=g*j}}return!b.charge}}function b(a){a.px=ig.event.x,a.py=ig.event.y,i.resume()}var c,d,e,f,g,h,i={},j=ig.dispatch("start","tick","end"),k=[1,1],l=.9,m=oi,n=pi,o=-30,p=qi,q=.1,r=.64,s=[],u=[];return i.tick=function(){if((e*=.99)<.005)return c=null,j.end({type:"end",alpha:e=0}),!0;var b,d,i,m,n,p,r,t,v,w=s.length,x=u.length;for(d=0;d<x;++d)i=u[d],m=i.source,n=i.target,t=n.x-m.x,v=n.y-m.y,(p=t*t+v*v)&&(p=e*g[d]*((p=Math.sqrt(p))-f[d])/p,t*=p,v*=p,n.x-=t*(r=m.weight+n.weight?m.weight/(m.weight+n.weight):.5),n.y-=v*r,m.x+=t*(r=1-r),m.y+=v*r);if((r=e*q)&&(t=k[0]/2,v=k[1]/2,d=-1,r))for(;++d<w;)i=s[d],i.x+=(t-i.x)*r,i.y+=(v-i.y)*r;if(o)for(de(b=ig.geom.quadtree(s),e,h),d=-1;++d<w;)(i=s[d]).fixed||b.visit(a(i));for(d=-1;++d<w;)i=s[d],i.fixed?(i.x=i.px,i.y=i.py):(i.x-=(i.px-(i.px=i.x))*l,i.y-=(i.py-(i.py=i.y))*l);j.tick({type:"tick",alpha:e})},i.nodes=function(a){return arguments.length?(s=a,i):s},i.links=function(a){return arguments.length?(u=a,i):u},i.size=function(a){return arguments.length?(k=a,i):k},i.linkDistance=function(a){return arguments.length?(m="function"==typeof a?a:+a,i):m},i.distance=i.linkDistance,i.linkStrength=function(a){return arguments.length?(n="function"==typeof a?a:+a,i):n},i.friction=function(a){return arguments.length?(l=+a,i):l},i.charge=function(a){return arguments.length?(o="function"==typeof a?a:+a,i):o},i.chargeDistance=function(a){return arguments.length?(p=a*a,i):Math.sqrt(p)},i.gravity=function(a){return arguments.length?(q=+a,i):q},i.theta=function(a){return arguments.length?(r=a*a,i):Math.sqrt(r)},i.alpha=function(a){return arguments.length?(a=+a,e?a>0?e=a:(c.c=null,c.t=NaN,c=null,j.end({type:"end",alpha:e=0})):a>0&&(j.start({type:"start",alpha:e=a}),c=Ga(i.tick)),i):e},i.start=function(){function a(a,d){if(!c){for(c=new Array(e),i=0;i<e;++i)c[i]=[];for(i=0;i<j;++i){var f=u[i];c[f.source.index].push(f.target),c[f.target.index].push(f.source)}}for(var g,h=c[b],i=-1,k=h.length;++i<k;)if(!isNaN(g=h[i][a]))return g;return Math.random()*d}var b,c,d,e=s.length,j=u.length,l=k[0],p=k[1];for(b=0;b<e;++b)(d=s[b]).index=b,d.weight=0;for(b=0;b<j;++b)d=u[b],"number"==typeof d.source&&(d.source=s[d.source]),"number"==typeof d.target&&(d.target=s[d.target]),++d.source.weight,++d.target.weight;for(b=0;b<e;++b)d=s[b],isNaN(d.x)&&(d.x=a("x",l)),isNaN(d.y)&&(d.y=a("y",p)),isNaN(d.px)&&(d.px=d.x),isNaN(d.py)&&(d.py=d.y);if(f=[],"function"==typeof m)for(b=0;b<j;++b)f[b]=+m.call(this,u[b],b);else for(b=0;b<j;++b)f[b]=m;if(g=[],"function"==typeof n)for(b=0;b<j;++b)g[b]=+n.call(this,u[b],b);else for(b=0;b<j;++b)g[b]=n;if(h=[],"function"==typeof o)for(b=0;b<e;++b)h[b]=+o.call(this,s[b],b);else for(b=0;b<e;++b)h[b]=o;return i.resume()},i.resume=function(){return i.alpha(.1)},i.stop=function(){return i.alpha(0)},i.drag=function(){if(d||(d=ig.behavior.drag().origin(t).on("dragstart.force",_d).on("drag.force",b).on("dragend.force",ae)),!arguments.length)return d;this.on("mouseover.force",be).on("mouseout.force",ce).call(d)},ig.rebind(i,j,"on")};var oi=20,pi=1,qi=1/0;ig.layout.hierarchy=function(){function a(e){var f,g=[e],h=[];for(e.depth=0;null!=(f=g.pop());)if(h.push(f),(j=c.call(a,f,f.depth))&&(i=j.length)){for(var i,j,k;--i>=0;)g.push(k=j[i]),k.parent=f,k.depth=f.depth+1;d&&(f.value=0),f.children=j}else d&&(f.value=+d.call(a,f,f.depth)||0),delete f.children;return ge(e,function(a){var c,e;b&&(c=a.children)&&c.sort(b),d&&(e=a.parent)&&(e.value+=a.value)}),h}var b=je,c=he,d=ie;return a.sort=function(c){return arguments.length?(b=c,a):b},a.children=function(b){return arguments.length?(c=b,a):c},a.value=function(b){return arguments.length?(d=b,a):d},a.revalue=function(b){return d&&(fe(b,function(a){a.children&&(a.value=0)}),ge(b,function(b){var c;b.children||(b.value=+d.call(a,b,b.depth)||0),(c=b.parent)&&(c.value+=b.value)})),b},a},ig.layout.partition=function(){function a(b,c,d,e){var f=b.children;if(b.x=c,b.y=b.depth*e,b.dx=d,b.dy=e,f&&(g=f.length)){var g,h,i,j=-1;for(d=b.value?d/b.value:0;++j<g;)a(h=f[j],c,i=h.value*d,e),c+=i}}function b(a){var c=a.children,d=0;if(c&&(e=c.length))for(var e,f=-1;++f<e;)d=Math.max(d,b(c[f]));return 1+d}function c(c,f){var g=d.call(this,c,f);return a(g[0],0,e[0],e[1]/b(g[0])),g}var d=ig.layout.hierarchy(),e=[1,1];return c.size=function(a){return arguments.length?(e=a,c):e},ee(c,d)},ig.layout.pie=function(){function a(g){var h,i=g.length,j=g.map(function(c,d){return+b.call(a,c,d)}),k=+("function"==typeof d?d.apply(this,arguments):d),l=("function"==typeof e?e.apply(this,arguments):e)-k,m=Math.min(Math.abs(l)/i,+("function"==typeof f?f.apply(this,arguments):f)),n=m*(l<0?-1:1),o=ig.sum(j),p=o?(l-i*n)/o:0,q=ig.range(i),r=[];return null!=c&&q.sort(c===ri?function(a,b){return j[b]-j[a]}:function(a,b){return c(g[a],g[b])}),q.forEach(function(a){r[a]={data:g[a],value:h=j[a],startAngle:k,endAngle:k+=h*p+n,padAngle:m}}),r}var b=Number,c=ri,d=0,e=Mg,f=0;return a.value=function(c){return arguments.length?(b=c,a):b},a.sort=function(b){return arguments.length?(c=b,a):c},a.startAngle=function(b){return arguments.length?(d=b,a):d},a.endAngle=function(b){return arguments.length?(e=b,a):e},a.padAngle=function(b){return arguments.length?(f=b,a):f},a};var ri={};ig.layout.stack=function(){function a(h,i){if(!(m=h.length))return h;var j=h.map(function(c,d){return b.call(a,c,d)}),k=j.map(function(b){return b.map(function(b,c){return[f.call(a,b,c),g.call(a,b,c)]})}),l=c.call(a,k,i);j=ig.permute(j,l),k=ig.permute(k,l);var m,n,o,p,q=d.call(a,k,i),r=j[0].length;for(o=0;o<r;++o)for(e.call(a,j[0][o],p=q[o],k[0][o][1]),n=1;n<m;++n)e.call(a,j[n][o],p+=k[n-1][o][1],k[n][o][1]);return h}var b=t,c=oe,d=pe,e=ne,f=le,g=me;return a.values=function(c){return arguments.length?(b=c,a):b},a.order=function(b){return arguments.length?(c="function"==typeof b?b:si.get(b)||oe,a):c},a.offset=function(b){return arguments.length?(d="function"==typeof b?b:ti.get(b)||pe,a):d},a.x=function(b){return arguments.length?(f=b,a):f},a.y=function(b){return arguments.length?(g=b,a):g},
+a.out=function(b){return arguments.length?(e=b,a):e},a};var si=ig.map({"inside-out":function(a){var b,c,d=a.length,e=a.map(qe),f=a.map(re),g=ig.range(d).sort(function(a,b){return e[a]-e[b]}),h=0,i=0,j=[],k=[];for(b=0;b<d;++b)c=g[b],h<i?(h+=f[c],j.push(c)):(i+=f[c],k.push(c));return k.reverse().concat(j)},reverse:function(a){return ig.range(a.length).reverse()},default:oe}),ti=ig.map({silhouette:function(a){var b,c,d,e=a.length,f=a[0].length,g=[],h=0,i=[];for(c=0;c<f;++c){for(b=0,d=0;b<e;b++)d+=a[b][c][1];d>h&&(h=d),g.push(d)}for(c=0;c<f;++c)i[c]=(h-g[c])/2;return i},wiggle:function(a){var b,c,d,e,f,g,h,i,j,k=a.length,l=a[0],m=l.length,n=[];for(n[0]=i=j=0,c=1;c<m;++c){for(b=0,e=0;b<k;++b)e+=a[b][c][1];for(b=0,f=0,h=l[c][0]-l[c-1][0];b<k;++b){for(d=0,g=(a[b][c][1]-a[b][c-1][1])/(2*h);d<b;++d)g+=(a[d][c][1]-a[d][c-1][1])/h;f+=g*a[b][c][1]}n[c]=i-=e?f/e*h:0,i<j&&(j=i)}for(c=0;c<m;++c)n[c]-=j;return n},expand:function(a){var b,c,d,e=a.length,f=a[0].length,g=1/e,h=[];for(c=0;c<f;++c){for(b=0,d=0;b<e;b++)d+=a[b][c][1];if(d)for(b=0;b<e;b++)a[b][c][1]/=d;else for(b=0;b<e;b++)a[b][c][1]=g}for(c=0;c<f;++c)h[c]=0;return h},zero:pe});ig.layout.histogram=function(){function a(a,f){for(var g,h,i=[],j=a.map(c,this),k=d.call(this,j,f),l=e.call(this,k,j,f),f=-1,m=j.length,n=l.length-1,o=b?1:1/m;++f<n;)g=i[f]=[],g.dx=l[f+1]-(g.x=l[f]),g.y=0;if(n>0)for(f=-1;++f<m;)(h=j[f])>=k[0]&&h<=k[1]&&(g=i[ig.bisect(l,h,1,n)-1],g.y+=o,g.push(a[f]));return i}var b=!0,c=Number,d=ve,e=te;return a.value=function(b){return arguments.length?(c=b,a):c},a.range=function(b){return arguments.length?(d=Ba(b),a):d},a.bins=function(b){return arguments.length?(e="number"==typeof b?function(a){return ue(a,b)}:Ba(b),a):e},a.frequency=function(c){return arguments.length?(b=!!c,a):b},a},ig.layout.pack=function(){function a(a,f){var g=c.call(this,a,f),h=g[0],i=e[0],j=e[1],k=null==b?Math.sqrt:"function"==typeof b?b:function(){return b};if(h.x=h.y=0,ge(h,function(a){a.r=+k(a.value)}),ge(h,Ae),d){var l=d*(b?1:Math.max(2*h.r/i,2*h.r/j))/2;ge(h,function(a){a.r+=l}),ge(h,Ae),ge(h,function(a){a.r-=l})}return De(h,i/2,j/2,b?1:1/Math.max(2*h.r/i,2*h.r/j)),g}var b,c=ig.layout.hierarchy().sort(we),d=0,e=[1,1];return a.size=function(b){return arguments.length?(e=b,a):e},a.radius=function(c){return arguments.length?(b=null==c||"function"==typeof c?c:+c,a):b},a.padding=function(b){return arguments.length?(d=+b,a):d},ee(a,c)},ig.layout.tree=function(){function a(a,e){var k=g.call(this,a,e),l=k[0],m=b(l);if(ge(m,c),m.parent.m=-m.z,fe(m,d),j)fe(l,f);else{var n=l,o=l,p=l;fe(l,function(a){a.x<n.x&&(n=a),a.x>o.x&&(o=a),a.depth>p.depth&&(p=a)});var q=h(n,o)/2-n.x,r=i[0]/(o.x+h(o,n)/2+q),s=i[1]/(p.depth||1);fe(l,function(a){a.x=(a.x+q)*r,a.y=a.depth*s})}return k}function b(a){for(var b,c={A:null,children:[a]},d=[c];null!=(b=d.pop());)for(var e,f=b.children,g=0,h=f.length;g<h;++g)d.push((f[g]=e={_:f[g],parent:b,children:(e=f[g].children)&&e.slice()||[],A:null,a:null,z:0,m:0,c:0,s:0,t:null,i:g}).a=e);return c.children[0]}function c(a){var b=a.children,c=a.parent.children,d=a.i?c[a.i-1]:null;if(b.length){Je(a);var f=(b[0].z+b[b.length-1].z)/2;d?(a.z=d.z+h(a._,d._),a.m=a.z-f):a.z=f}else d&&(a.z=d.z+h(a._,d._));a.parent.A=e(a,d,a.parent.A||c[0])}function d(a){a._.x=a.z+a.parent.m,a.m+=a.parent.m}function e(a,b,c){if(b){for(var d,e=a,f=a,g=b,i=e.parent.children[0],j=e.m,k=f.m,l=g.m,m=i.m;g=He(g),e=Ge(e),g&&e;)i=Ge(i),f=He(f),f.a=a,d=g.z+l-e.z-j+h(g._,e._),d>0&&(Ie(Ke(g,a,c),a,d),j+=d,k+=d),l+=g.m,j+=e.m,m+=i.m,k+=f.m;g&&!He(f)&&(f.t=g,f.m+=l-k),e&&!Ge(i)&&(i.t=e,i.m+=j-m,c=a)}return c}function f(a){a.x*=i[0],a.y=a.depth*i[1]}var g=ig.layout.hierarchy().sort(null).value(null),h=Fe,i=[1,1],j=null;return a.separation=function(b){return arguments.length?(h=b,a):h},a.size=function(b){return arguments.length?(j=null==(i=b)?f:null,a):j?null:i},a.nodeSize=function(b){return arguments.length?(j=null==(i=b)?null:f,a):j?i:null},ee(a,g)},ig.layout.cluster=function(){function a(a,f){var g,h=b.call(this,a,f),i=h[0],j=0;ge(i,function(a){var b=a.children;b&&b.length?(a.x=Me(b),a.y=Le(b)):(a.x=g?j+=c(a,g):0,a.y=0,g=a)});var k=Ne(i),l=Oe(i),m=k.x-c(k,l)/2,n=l.x+c(l,k)/2;return ge(i,e?function(a){a.x=(a.x-i.x)*d[0],a.y=(i.y-a.y)*d[1]}:function(a){a.x=(a.x-m)/(n-m)*d[0],a.y=(1-(i.y?a.y/i.y:1))*d[1]}),h}var b=ig.layout.hierarchy().sort(null).value(null),c=Fe,d=[1,1],e=!1;return a.separation=function(b){return arguments.length?(c=b,a):c},a.size=function(b){return arguments.length?(e=null==(d=b),a):e?null:d},a.nodeSize=function(b){return arguments.length?(e=null!=(d=b),a):e?d:null},ee(a,b)},ig.layout.treemap=function(){function a(a,b){for(var c,d,e=-1,f=a.length;++e<f;)d=(c=a[e]).value*(b<0?0:b),c.area=isNaN(d)||d<=0?0:d}function b(c){var f=c.children;if(f&&f.length){var g,h,i,j=l(c),k=[],m=f.slice(),o=1/0,p="slice"===n?j.dx:"dice"===n?j.dy:"slice-dice"===n?1&c.depth?j.dy:j.dx:Math.min(j.dx,j.dy);for(a(m,j.dx*j.dy/c.value),k.area=0;(i=m.length)>0;)k.push(g=m[i-1]),k.area+=g.area,"squarify"!==n||(h=d(k,p))<=o?(m.pop(),o=h):(k.area-=k.pop().area,e(k,p,j,!1),p=Math.min(j.dx,j.dy),k.length=k.area=0,o=1/0);k.length&&(e(k,p,j,!0),k.length=k.area=0),f.forEach(b)}}function c(b){var d=b.children;if(d&&d.length){var f,g=l(b),h=d.slice(),i=[];for(a(h,g.dx*g.dy/b.value),i.area=0;f=h.pop();)i.push(f),i.area+=f.area,null!=f.z&&(e(i,f.z?g.dx:g.dy,g,!h.length),i.length=i.area=0);d.forEach(c)}}function d(a,b){for(var c,d=a.area,e=0,f=1/0,g=-1,h=a.length;++g<h;)(c=a[g].area)&&(c<f&&(f=c),c>e&&(e=c));return d*=d,b*=b,d?Math.max(b*e*o/d,d/(b*f*o)):1/0}function e(a,b,c,d){var e,f=-1,g=a.length,h=c.x,j=c.y,k=b?i(a.area/b):0;if(b==c.dx){for((d||k>c.dy)&&(k=c.dy);++f<g;)e=a[f],e.x=h,e.y=j,e.dy=k,h+=e.dx=Math.min(c.x+c.dx-h,k?i(e.area/k):0);e.z=!0,e.dx+=c.x+c.dx-h,c.y+=k,c.dy-=k}else{for((d||k>c.dx)&&(k=c.dx);++f<g;)e=a[f],e.x=h,e.y=j,e.dx=k,j+=e.dy=Math.min(c.y+c.dy-j,k?i(e.area/k):0);e.z=!1,e.dy+=c.y+c.dy-j,c.x+=k,c.dx-=k}}function f(d){var e=g||h(d),f=e[0];return f.x=f.y=0,f.value?(f.dx=j[0],f.dy=j[1]):f.dx=f.dy=0,g&&h.revalue(f),a([f],f.dx*f.dy/f.value),(g?c:b)(f),m&&(g=e),e}var g,h=ig.layout.hierarchy(),i=Math.round,j=[1,1],k=null,l=Pe,m=!1,n="squarify",o=.5*(1+Math.sqrt(5));return f.size=function(a){return arguments.length?(j=a,f):j},f.padding=function(a){function b(b){var c=a.call(f,b,b.depth);return null==c?Pe(b):Qe(b,"number"==typeof c?[c,c,c,c]:c)}function c(b){return Qe(b,a)}if(!arguments.length)return k;var d;return l=null==(k=a)?Pe:"function"==(d=typeof a)?b:"number"===d?(a=[a,a,a,a],c):c,f},f.round=function(a){return arguments.length?(i=a?Math.round:Number,f):i!=Number},f.sticky=function(a){return arguments.length?(m=a,g=null,f):m},f.ratio=function(a){return arguments.length?(o=a,f):o},f.mode=function(a){return arguments.length?(n=a+"",f):n},ee(f,h)},ig.random={normal:function(a,b){var c=arguments.length;return c<2&&(b=1),c<1&&(a=0),function(){var c,d,e;do{c=2*Math.random()-1,d=2*Math.random()-1,e=c*c+d*d}while(!e||e>1);return a+b*c*Math.sqrt(-2*Math.log(e)/e)}},logNormal:function(){var a=ig.random.normal.apply(ig,arguments);return function(){return Math.exp(a())}},bates:function(a){var b=ig.random.irwinHall(a);return function(){return b()/a}},irwinHall:function(a){return function(){for(var b=0,c=0;c<a;c++)b+=Math.random();return b}}},ig.scale={};var ui={floor:t,ceil:t};ig.scale.linear=function(){return Xe([0,1],[0,1],td,!1)};var vi={s:1,g:1,p:1,r:1,e:1};ig.scale.log=function(){return df(ig.scale.linear().domain([0,1]),10,!0,[1,10])};var wi=ig.format(".0e"),xi={floor:function(a){return-Math.ceil(-a)},ceil:function(a){return-Math.floor(-a)}};ig.scale.pow=function(){return ef(ig.scale.linear(),1,[0,1])},ig.scale.sqrt=function(){return ig.scale.pow().exponent(.5)},ig.scale.ordinal=function(){return gf([],{t:"range",a:[[]]})},ig.scale.category10=function(){return ig.scale.ordinal().range(yi)},ig.scale.category20=function(){return ig.scale.ordinal().range(zi)},ig.scale.category20b=function(){return ig.scale.ordinal().range(Ai)},ig.scale.category20c=function(){return ig.scale.ordinal().range(Bi)};var yi=[2062260,16744206,2924588,14034728,9725885,9197131,14907330,8355711,12369186,1556175].map(ua),zi=[2062260,11454440,16744206,16759672,2924588,10018698,14034728,16750742,9725885,12955861,9197131,12885140,14907330,16234194,8355711,13092807,12369186,14408589,1556175,10410725].map(ua),Ai=[3750777,5395619,7040719,10264286,6519097,9216594,11915115,13556636,9202993,12426809,15186514,15190932,8666169,11356490,14049643,15177372,8077683,10834324,13528509,14589654].map(ua),Bi=[3244733,7057110,10406625,13032431,15095053,16616764,16625259,16634018,3253076,7652470,10607003,13101504,7695281,10394312,12369372,14342891,6513507,9868950,12434877,14277081].map(ua);ig.scale.quantile=function(){return hf([],[])},ig.scale.quantize=function(){return jf(0,1,[0,1])},ig.scale.threshold=function(){return kf([.5],[0,1])},ig.scale.identity=function(){return lf([0,1])},ig.svg={},ig.svg.arc=function(){function a(){var a=Math.max(0,+c.apply(this,arguments)),j=Math.max(0,+d.apply(this,arguments)),k=g.apply(this,arguments)-Og,l=h.apply(this,arguments)-Og,m=Math.abs(l-k),n=k>l?0:1;if(j<a&&(o=j,j=a,a=o),m>=Ng)return b(j,n)+(a?b(a,1-n):"")+"Z";var o,p,q,r,s,t,u,v,w,x,y,z,A=0,B=0,C=[];if((r=(+i.apply(this,arguments)||0)/2)&&(q=f===Ci?Math.sqrt(a*a+j*j):+f.apply(this,arguments),n||(B*=-1),j&&(B=ca(q/j*Math.sin(r))),a&&(A=ca(q/a*Math.sin(r)))),j){s=j*Math.cos(k+B),t=j*Math.sin(k+B),u=j*Math.cos(l-B),v=j*Math.sin(l-B);var D=Math.abs(l-k-2*B)<=Lg?0:1;if(B&&sf(s,t,u,v)===n^D){var E=(k+l)/2;s=j*Math.cos(E),t=j*Math.sin(E),u=v=null}}else s=t=0;if(a){w=a*Math.cos(l-A),x=a*Math.sin(l-A),y=a*Math.cos(k+A),z=a*Math.sin(k+A);var F=Math.abs(k-l+2*A)<=Lg?0:1;if(A&&sf(w,x,y,z)===1-n^F){var G=(k+l)/2;w=a*Math.cos(G),x=a*Math.sin(G),y=z=null}}else w=x=0;if(m>Jg&&(o=Math.min(Math.abs(j-a)/2,+e.apply(this,arguments)))>.001){p=a<j^n?0:1;var H=o,I=o;if(m<Lg){var J=null==y?[w,x]:null==u?[s,t]:Ic([s,t],[y,z],[u,v],[w,x]),K=s-J[0],L=t-J[1],M=u-J[0],N=v-J[1],O=1/Math.sin(Math.acos((K*M+L*N)/(Math.sqrt(K*K+L*L)*Math.sqrt(M*M+N*N)))/2),P=Math.sqrt(J[0]*J[0]+J[1]*J[1]);I=Math.min(o,(a-P)/(O-1)),H=Math.min(o,(j-P)/(O+1))}if(null!=u){var Q=tf(null==y?[w,x]:[y,z],[s,t],j,H,n),R=tf([u,v],[w,x],j,H,n);o===H?C.push("M",Q[0],"A",H,",",H," 0 0,",p," ",Q[1],"A",j,",",j," 0 ",1-n^sf(Q[1][0],Q[1][1],R[1][0],R[1][1]),",",n," ",R[1],"A",H,",",H," 0 0,",p," ",R[0]):C.push("M",Q[0],"A",H,",",H," 0 1,",p," ",R[0])}else C.push("M",s,",",t);if(null!=y){var S=tf([s,t],[y,z],a,-I,n),T=tf([w,x],null==u?[s,t]:[u,v],a,-I,n);o===I?C.push("L",T[0],"A",I,",",I," 0 0,",p," ",T[1],"A",a,",",a," 0 ",n^sf(T[1][0],T[1][1],S[1][0],S[1][1]),",",1-n," ",S[1],"A",I,",",I," 0 0,",p," ",S[0]):C.push("L",T[0],"A",I,",",I," 0 0,",p," ",S[0])}else C.push("L",w,",",x)}else C.push("M",s,",",t),null!=u&&C.push("A",j,",",j," 0 ",D,",",n," ",u,",",v),C.push("L",w,",",x),null!=y&&C.push("A",a,",",a," 0 ",F,",",1-n," ",y,",",z);return C.push("Z"),C.join("")}function b(a,b){return"M0,"+a+"A"+a+","+a+" 0 1,"+b+" 0,"+-a+"A"+a+","+a+" 0 1,"+b+" 0,"+a}var c=nf,d=of,e=mf,f=Ci,g=pf,h=qf,i=rf;return a.innerRadius=function(b){return arguments.length?(c=Ba(b),a):c},a.outerRadius=function(b){return arguments.length?(d=Ba(b),a):d},a.cornerRadius=function(b){return arguments.length?(e=Ba(b),a):e},a.padRadius=function(b){return arguments.length?(f=b==Ci?Ci:Ba(b),a):f},a.startAngle=function(b){return arguments.length?(g=Ba(b),a):g},a.endAngle=function(b){return arguments.length?(h=Ba(b),a):h},a.padAngle=function(b){return arguments.length?(i=Ba(b),a):i},a.centroid=function(){var a=(+c.apply(this,arguments)+ +d.apply(this,arguments))/2,b=(+g.apply(this,arguments)+ +h.apply(this,arguments))/2-Og;return[Math.cos(b)*a,Math.sin(b)*a]},a};var Ci="auto";ig.svg.line=function(){return uf(t)};var Di=ig.map({linear:vf,"linear-closed":wf,step:xf,"step-before":yf,"step-after":zf,basis:Ff,"basis-open":Gf,"basis-closed":Hf,bundle:If,cardinal:Cf,"cardinal-open":Af,"cardinal-closed":Bf,monotone:Of});Di.forEach(function(a,b){b.key=a,b.closed=/-closed$/.test(a)});var Ei=[0,2/3,1/3,0],Fi=[0,1/3,2/3,0],Gi=[0,1/6,2/3,1/6];ig.svg.line.radial=function(){var a=uf(Pf);return a.radius=a.x,delete a.x,a.angle=a.y,delete a.y,a},yf.reverse=zf,zf.reverse=yf,ig.svg.area=function(){return Qf(t)},ig.svg.area.radial=function(){var a=Qf(Pf);return a.radius=a.x,delete a.x,a.innerRadius=a.x0,delete a.x0,a.outerRadius=a.x1,delete a.x1,a.angle=a.y,delete a.y,a.startAngle=a.y0,delete a.y0,a.endAngle=a.y1,delete a.y1,a},ig.svg.chord=function(){function a(a,h){var i=b(this,f,a,h),j=b(this,g,a,h);return"M"+i.p0+d(i.r,i.p1,i.a1-i.a0)+(c(i,j)?e(i.r,i.p1,i.r,i.p0):e(i.r,i.p1,j.r,j.p0)+d(j.r,j.p1,j.a1-j.a0)+e(j.r,j.p1,i.r,i.p0))+"Z"}function b(a,b,c,d){var e=b.call(a,c,d),f=h.call(a,e,d),g=i.call(a,e,d)-Og,k=j.call(a,e,d)-Og;return{r:f,a0:g,a1:k,p0:[f*Math.cos(g),f*Math.sin(g)],p1:[f*Math.cos(k),f*Math.sin(k)]}}function c(a,b){return a.a0==b.a0&&a.a1==b.a1}function d(a,b,c){return"A"+a+","+a+" 0 "+ +(c>Lg)+",1 "+b}function e(a,b,c,d){return"Q 0,0 "+d}var f=tc,g=uc,h=Rf,i=pf,j=qf;return a.radius=function(b){return arguments.length?(h=Ba(b),a):h},a.source=function(b){return arguments.length?(f=Ba(b),a):f},a.target=function(b){return arguments.length?(g=Ba(b),a):g},a.startAngle=function(b){return arguments.length?(i=Ba(b),a):i},a.endAngle=function(b){return arguments.length?(j=Ba(b),a):j},a},ig.svg.diagonal=function(){function a(a,e){var f=b.call(this,a,e),g=c.call(this,a,e),h=(f.y+g.y)/2,i=[f,{x:f.x,y:h},{x:g.x,y:h},g];return i=i.map(d),"M"+i[0]+"C"+i[1]+" "+i[2]+" "+i[3]}var b=tc,c=uc,d=Sf;return a.source=function(c){return arguments.length?(b=Ba(c),a):b},a.target=function(b){return arguments.length?(c=Ba(b),a):c},a.projection=function(b){return arguments.length?(d=b,a):d},a},ig.svg.diagonal.radial=function(){var a=ig.svg.diagonal(),b=Sf,c=a.projection;return a.projection=function(a){return arguments.length?c(Tf(b=a)):b},a},ig.svg.symbol=function(){function a(a,d){return(Hi.get(b.call(this,a,d))||Wf)(c.call(this,a,d))}var b=Vf,c=Uf;return a.type=function(c){return arguments.length?(b=Ba(c),a):b},a.size=function(b){return arguments.length?(c=Ba(b),a):c},a};var Hi=ig.map({circle:Wf,cross:function(a){var b=Math.sqrt(a/5)/2;return"M"+-3*b+","+-b+"H"+-b+"V"+-3*b+"H"+b+"V"+-b+"H"+3*b+"V"+b+"H"+b+"V"+3*b+"H"+-b+"V"+b+"H"+-3*b+"Z"},diamond:function(a){var b=Math.sqrt(a/(2*Ji)),c=b*Ji;return"M0,"+-b+"L"+c+",0 0,"+b+" "+-c+",0Z"},square:function(a){var b=Math.sqrt(a)/2;return"M"+-b+","+-b+"L"+b+","+-b+" "+b+","+b+" "+-b+","+b+"Z"},"triangle-down":function(a){var b=Math.sqrt(a/Ii),c=b*Ii/2;return"M0,"+c+"L"+b+","+-c+" "+-b+","+-c+"Z"},"triangle-up":function(a){var b=Math.sqrt(a/Ii),c=b*Ii/2;return"M0,"+-c+"L"+b+","+c+" "+-b+","+c+"Z"}});ig.svg.symbolTypes=Hi.keys();var Ii=Math.sqrt(3),Ji=Math.tan(30*Pg);Bg.transition=function(a){for(var b,c,d=Ki||++Oi,e=_f(a),f=[],g=Li||{time:Date.now(),ease:Ad,delay:0,duration:250},h=-1,i=this.length;++h<i;){f.push(b=[]);for(var j=this[h],k=-1,l=j.length;++k<l;)(c=j[k])&&ag(c,k,e,d,g),b.push(c)}return Yf(f,e,d)},Bg.interrupt=function(a){return this.each(null==a?Mi:Xf(_f(a)))};var Ki,Li,Mi=Xf(_f()),Ni=[],Oi=0;Ni.call=Bg.call,Ni.empty=Bg.empty,Ni.node=Bg.node,Ni.size=Bg.size,ig.transition=function(a,b){return a&&a.transition?Ki?a.transition(b):a:ig.selection().transition(a)},ig.transition.prototype=Ni,Ni.select=function(a){var b,c,d,e=this.id,f=this.namespace,g=[];a=D(a);for(var h=-1,i=this.length;++h<i;){g.push(b=[]);for(var j=this[h],k=-1,l=j.length;++k<l;)(d=j[k])&&(c=a.call(d,d.__data__,k,h))?("__data__"in d&&(c.__data__=d.__data__),ag(c,k,f,e,d[f][e]),b.push(c)):b.push(null)}return Yf(g,f,e)},Ni.selectAll=function(a){var b,c,d,e,f,g=this.id,h=this.namespace,i=[];a=E(a);for(var j=-1,k=this.length;++j<k;)for(var l=this[j],m=-1,n=l.length;++m<n;)if(d=l[m]){f=d[h][g],c=a.call(d,d.__data__,m,j),i.push(b=[]);for(var o=-1,p=c.length;++o<p;)(e=c[o])&&ag(e,o,h,g,f),b.push(e)}return Yf(i,h,g)},Ni.filter=function(a){var b,c,d,e=[];"function"!=typeof a&&(a=Q(a));for(var f=0,g=this.length;f<g;f++){e.push(b=[]);for(var c=this[f],h=0,i=c.length;h<i;h++)(d=c[h])&&a.call(d,d.__data__,h,f)&&b.push(d)}return Yf(e,this.namespace,this.id)},Ni.tween=function(a,b){var c=this.id,d=this.namespace;return arguments.length<2?this.node()[d][c].tween.get(a):S(this,null==b?function(b){b[d][c].tween.remove(a)}:function(e){e[d][c].tween.set(a,b)})},Ni.attr=function(a,b){function c(){this.removeAttribute(h)}function d(){this.removeAttributeNS(h.space,h.local)}function e(a){return null==a?c:(a+="",function(){var b,c=this.getAttribute(h);return c!==a&&(b=g(c,a),function(a){this.setAttribute(h,b(a))})})}function f(a){return null==a?d:(a+="",function(){var b,c=this.getAttributeNS(h.space,h.local);return c!==a&&(b=g(c,a),function(a){this.setAttributeNS(h.space,h.local,b(a))})})}if(arguments.length<2){for(b in a)this.attr(b,a[b]);return this}var g="transform"==a?Vd:td,h=ig.ns.qualify(a);return Zf(this,"attr."+a,b,h.local?f:e)},Ni.attrTween=function(a,b){function c(a,c){var d=b.call(this,a,c,this.getAttribute(e));return d&&function(a){this.setAttribute(e,d(a))}}function d(a,c){var d=b.call(this,a,c,this.getAttributeNS(e.space,e.local));return d&&function(a){this.setAttributeNS(e.space,e.local,d(a))}}var e=ig.ns.qualify(a);return this.tween("attr."+a,e.local?d:c)},Ni.style=function(a,b,d){function e(){this.style.removeProperty(a)}function f(b){return null==b?e:(b+="",function(){var e,f=c(this).getComputedStyle(this,null).getPropertyValue(a);return f!==b&&(e=td(f,b),function(b){this.style.setProperty(a,e(b),d)})})}var g=arguments.length;if(g<3){if("string"!=typeof a){g<2&&(b="");for(d in a)this.style(d,a[d],b);return this}d=""}return Zf(this,"style."+a,b,f)},Ni.styleTween=function(a,b,d){function e(e,f){var g=b.call(this,e,f,c(this).getComputedStyle(this,null).getPropertyValue(a));return g&&function(b){this.style.setProperty(a,g(b),d)}}return arguments.length<3&&(d=""),this.tween("style."+a,e)},Ni.text=function(a){return Zf(this,"text",a,$f)},Ni.remove=function(){var a=this.namespace;return this.each("end.transition",function(){var b;this[a].count<2&&(b=this.parentNode)&&b.removeChild(this)})},Ni.ease=function(a){var b=this.id,c=this.namespace;return arguments.length<1?this.node()[c][b].ease:("function"!=typeof a&&(a=ig.ease.apply(ig,arguments)),S(this,function(d){d[c][b].ease=a}))},Ni.delay=function(a){var b=this.id,c=this.namespace;return arguments.length<1?this.node()[c][b].delay:S(this,"function"==typeof a?function(d,e,f){d[c][b].delay=+a.call(d,d.__data__,e,f)}:(a=+a,function(d){d[c][b].delay=a}))},Ni.duration=function(a){var b=this.id,c=this.namespace;return arguments.length<1?this.node()[c][b].duration:S(this,"function"==typeof a?function(d,e,f){d[c][b].duration=Math.max(1,a.call(d,d.__data__,e,f))}:(a=Math.max(1,a),function(d){d[c][b].duration=a}))},Ni.each=function(a,b){var c=this.id,d=this.namespace;if(arguments.length<2){var e=Li,f=Ki;try{Ki=c,S(this,function(b,e,f){Li=b[d][c],a.call(b,b.__data__,e,f)})}finally{Li=e,Ki=f}}else S(this,function(e){var f=e[d][c];(f.event||(f.event=ig.dispatch("start","end","interrupt"))).on(a,b)});return this},Ni.transition=function(){for(var a,b,c,d,e=this.id,f=++Oi,g=this.namespace,h=[],i=0,j=this.length;i<j;i++){h.push(a=[]);for(var b=this[i],k=0,l=b.length;k<l;k++)(c=b[k])&&(d=c[g][e],ag(c,k,g,f,{time:d.time,ease:d.ease,delay:d.delay+d.duration,duration:d.duration})),a.push(c)}return Yf(h,g,f)},ig.svg.axis=function(){function a(a){a.each(function(){var a,j=ig.select(this),k=this.__chart__||c,l=this.__chart__=c.copy(),m=null==i?l.ticks?l.ticks.apply(l,h):l.domain():i,n=null==b?l.tickFormat?l.tickFormat.apply(l,h):t:b,o=j.selectAll(".tick").data(m,l),p=o.enter().insert("g",".domain").attr("class","tick").style("opacity",Jg),q=ig.transition(o.exit()).style("opacity",Jg).remove(),r=ig.transition(o.order()).style("opacity",1),s=Math.max(e,0)+g,u=Se(l),v=j.selectAll(".domain").data([0]),w=(v.enter().append("path").attr("class","domain"),ig.transition(v));p.append("line"),p.append("text");var x,y,z,A,B=p.select("line"),C=r.select("line"),D=o.select("text").text(n),E=p.select("text"),F=r.select("text"),G="top"===d||"left"===d?-1:1;if("bottom"===d||"top"===d?(a=bg,x="x",z="y",y="x2",A="y2",D.attr("dy",G<0?"0em":".71em").style("text-anchor","middle"),w.attr("d","M"+u[0]+","+G*f+"V0H"+u[1]+"V"+G*f)):(a=cg,x="y",z="x",y="y2",A="x2",D.attr("dy",".32em").style("text-anchor",G<0?"end":"start"),w.attr("d","M"+G*f+","+u[0]+"H0V"+u[1]+"H"+G*f)),B.attr(A,G*e),E.attr(z,G*s),C.attr(y,0).attr(A,G*e),F.attr(x,0).attr(z,G*s),l.rangeBand){var H=l,I=H.rangeBand()/2;k=l=function(a){return H(a)+I}}else k.rangeBand?k=l:q.call(a,l,k);p.call(a,k,l),r.call(a,l,l)})}var b,c=ig.scale.linear(),d=Pi,e=6,f=6,g=3,h=[10],i=null;return a.scale=function(b){return arguments.length?(c=b,a):c},a.orient=function(b){return arguments.length?(d=b in Qi?b+"":Pi,a):d},a.ticks=function(){return arguments.length?(h=kg(arguments),a):h},a.tickValues=function(b){return arguments.length?(i=b,a):i},a.tickFormat=function(c){return arguments.length?(b=c,a):b},a.tickSize=function(b){var c=arguments.length;return c?(e=+b,f=+arguments[c-1],a):e},a.innerTickSize=function(b){return arguments.length?(e=+b,a):e},a.outerTickSize=function(b){return arguments.length?(f=+b,a):f},a.tickPadding=function(b){return arguments.length?(g=+b,a):g},a.tickSubdivide=function(){return arguments.length&&a},a};var Pi="bottom",Qi={top:1,right:1,bottom:1,left:1};ig.svg.brush=function(){function a(c){c.each(function(){var c=ig.select(this).style("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush",f).on("touchstart.brush",f),g=c.selectAll(".background").data([0]);g.enter().append("rect").attr("class","background").style("visibility","hidden").style("cursor","crosshair"),c.selectAll(".extent").data([0]).enter().append("rect").attr("class","extent").style("cursor","move");var h=c.selectAll(".resize").data(p,t);h.exit().remove(),h.enter().append("g").attr("class",function(a){return"resize "+a}).style("cursor",function(a){return Ri[a]}).append("rect").attr("x",function(a){return/[ew]$/.test(a)?-3:null}).attr("y",function(a){return/^[ns]/.test(a)?-3:null}).attr("width",6).attr("height",6).style("visibility","hidden"),h.style("display",a.empty()?"none":null);var i,l=ig.transition(c),m=ig.transition(g);j&&(i=Se(j),m.attr("x",i[0]).attr("width",i[1]-i[0]),d(l)),k&&(i=Se(k),m.attr("y",i[0]).attr("height",i[1]-i[0]),e(l)),b(l)})}function b(a){a.selectAll(".resize").attr("transform",function(a){return"translate("+l[+/e$/.test(a)]+","+m[+/^s/.test(a)]+")"})}function d(a){a.select(".extent").attr("x",l[0]),a.selectAll(".extent,.n>rect,.s>rect").attr("width",l[1]-l[0])}function e(a){a.select(".extent").attr("y",m[0]),a.selectAll(".extent,.e>rect,.w>rect").attr("height",m[1]-m[0])}function f(){function f(){32==ig.event.keyCode&&(D||(t=null,F[0]-=l[1],F[1]-=m[1],D=2),z())}function p(){32==ig.event.keyCode&&2==D&&(F[0]+=l[1],F[1]+=m[1],D=0,z())}function q(){var a=ig.mouse(v),c=!1;u&&(a[0]+=u[0],a[1]+=u[1]),D||(ig.event.altKey?(t||(t=[(l[0]+l[1])/2,(m[0]+m[1])/2]),F[0]=l[+(a[0]<t[0])],F[1]=m[+(a[1]<t[1])]):t=null),B&&r(a,j,0)&&(d(y),c=!0),C&&r(a,k,1)&&(e(y),c=!0),c&&(b(y),x({type:"brush",mode:D?"move":"resize"}))}function r(a,b,c){var d,e,f=Se(b),i=f[0],j=f[1],k=F[c],p=c?m:l,q=p[1]-p[0];if(D&&(i-=k,j-=q+k),d=(c?o:n)?Math.max(i,Math.min(j,a[c])):a[c],D?e=(d+=k)+q:(t&&(k=Math.max(i,Math.min(j,2*t[c]-d))),k<d?(e=d,d=k):e=k),p[0]!=d||p[1]!=e)return c?h=null:g=null,p[0]=d,p[1]=e,!0}function s(){q(),y.style("pointer-events","all").selectAll(".resize").style("display",a.empty()?"none":null),ig.select("body").style("cursor",null),G.on("mousemove.brush",null).on("mouseup.brush",null).on("touchmove.brush",null).on("touchend.brush",null).on("keydown.brush",null).on("keyup.brush",null),E(),x({type:"brushend"})}var t,u,v=this,w=ig.select(ig.event.target),x=i.of(v,arguments),y=ig.select(v),A=w.datum(),B=!/^(n|s)$/.test(A)&&j,C=!/^(e|w)$/.test(A)&&k,D=w.classed("extent"),E=Y(v),F=ig.mouse(v),G=ig.select(c(v)).on("keydown.brush",f).on("keyup.brush",p);if(ig.event.changedTouches?G.on("touchmove.brush",q).on("touchend.brush",s):G.on("mousemove.brush",q).on("mouseup.brush",s),y.interrupt().selectAll("*").interrupt(),D)F[0]=l[0]-F[0],F[1]=m[0]-F[1];else if(A){var H=+/w$/.test(A),I=+/^n/.test(A);u=[l[1-H]-F[0],m[1-I]-F[1]],F[0]=l[H],F[1]=m[I]}else ig.event.altKey&&(t=F.slice());y.style("pointer-events","none").selectAll(".resize").style("display",null),ig.select("body").style("cursor",w.style("cursor")),x({type:"brushstart"}),q()}var g,h,i=B(a,"brushstart","brush","brushend"),j=null,k=null,l=[0,0],m=[0,0],n=!0,o=!0,p=Si[0];return a.event=function(a){a.each(function(){var a=i.of(this,arguments),b={x:l,y:m,i:g,j:h},c=this.__chart__||b;this.__chart__=b,Ki?ig.select(this).transition().each("start.brush",function(){g=c.i,h=c.j,l=c.x,m=c.y,a({type:"brushstart"})}).tween("brush:brush",function(){var c=ud(l,b.x),d=ud(m,b.y);return g=h=null,function(e){l=b.x=c(e),m=b.y=d(e),a({type:"brush",mode:"resize"})}}).each("end.brush",function(){g=b.i,h=b.j,a({type:"brush",mode:"resize"}),a({type:"brushend"})}):(a({type:"brushstart"}),a({type:"brush",mode:"resize"}),a({type:"brushend"}))})},a.x=function(b){return arguments.length?(j=b,p=Si[!j<<1|!k],a):j},a.y=function(b){return arguments.length?(k=b,p=Si[!j<<1|!k],a):k},a.clamp=function(b){return arguments.length?(j&&k?(n=!!b[0],o=!!b[1]):j?n=!!b:k&&(o=!!b),a):j&&k?[n,o]:j?n:k?o:null},a.extent=function(b){var c,d,e,f,i;return arguments.length?(j&&(c=b[0],d=b[1],k&&(c=c[0],d=d[0]),g=[c,d],j.invert&&(c=j(c),d=j(d)),d<c&&(i=c,c=d,d=i),c==l[0]&&d==l[1]||(l=[c,d])),k&&(e=b[0],f=b[1],j&&(e=e[1],f=f[1]),h=[e,f],k.invert&&(e=k(e),f=k(f)),f<e&&(i=e,e=f,f=i),e==m[0]&&f==m[1]||(m=[e,f])),a):(j&&(g?(c=g[0],d=g[1]):(c=l[0],d=l[1],j.invert&&(c=j.invert(c),d=j.invert(d)),d<c&&(i=c,c=d,d=i))),k&&(h?(e=h[0],f=h[1]):(e=m[0],f=m[1],k.invert&&(e=k.invert(e),f=k.invert(f)),f<e&&(i=e,e=f,f=i))),j&&k?[[c,e],[d,f]]:j?[c,d]:k&&[e,f])},a.clear=function(){return a.empty()||(l=[0,0],m=[0,0],g=h=null),a},a.empty=function(){return!!j&&l[0]==l[1]||!!k&&m[0]==m[1]},ig.rebind(a,i,"on")};var Ri={n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Si=[["n","e","s","w","nw","ne","se","sw"],["e","w"],["n","s"],[]],Ti=kh.format=qh.timeFormat,Ui=Ti.utc,Vi=Ui("%Y-%m-%dT%H:%M:%S.%LZ");Ti.iso=Date.prototype.toISOString&&+new Date("2000-01-01T00:00:00.000Z")?dg:Vi,dg.parse=function(a){var b=new Date(a);return isNaN(b)?null:b},dg.toString=Vi.toString,kh.second=Pa(function(a){return new lh(1e3*Math.floor(a/1e3))},function(a,b){a.setTime(a.getTime()+1e3*Math.floor(b))},function(a){return a.getSeconds()}),kh.seconds=kh.second.range,kh.seconds.utc=kh.second.utc.range,kh.minute=Pa(function(a){return new lh(6e4*Math.floor(a/6e4))},function(a,b){a.setTime(a.getTime()+6e4*Math.floor(b))},function(a){return a.getMinutes()}),kh.minutes=kh.minute.range,kh.minutes.utc=kh.minute.utc.range,kh.hour=Pa(function(a){var b=a.getTimezoneOffset()/60;return new lh(36e5*(Math.floor(a/36e5-b)+b))},function(a,b){a.setTime(a.getTime()+36e5*Math.floor(b))},function(a){return a.getHours()}),kh.hours=kh.hour.range,kh.hours.utc=kh.hour.utc.range,kh.month=Pa(function(a){return a=kh.day(a),a.setDate(1),a},function(a,b){a.setMonth(a.getMonth()+b)},function(a){return a.getMonth()}),kh.months=kh.month.range,kh.months.utc=kh.month.utc.range;var Wi=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,2592e6,7776e6,31536e6],Xi=[[kh.second,1],[kh.second,5],[kh.second,15],[kh.second,30],[kh.minute,1],[kh.minute,5],[kh.minute,15],[kh.minute,30],[kh.hour,1],[kh.hour,3],[kh.hour,6],[kh.hour,12],[kh.day,1],[kh.day,2],[kh.week,1],[kh.month,1],[kh.month,3],[kh.year,1]],Yi=Ti.multi([[".%L",function(a){return a.getMilliseconds()}],[":%S",function(a){return a.getSeconds()}],["%I:%M",function(a){return a.getMinutes()}],["%I %p",function(a){return a.getHours()}],["%a %d",function(a){return a.getDay()&&1!=a.getDate()}],["%b %d",function(a){return 1!=a.getDate()}],["%B",function(a){return a.getMonth()}],["%Y",Eb]]),Zi={range:function(a,b,c){return ig.range(Math.ceil(a/c)*c,+b,c).map(fg)},floor:t,ceil:t};Xi.year=kh.year,kh.scale=function(){return eg(ig.scale.linear(),Xi,Yi)};var $i=Xi.map(function(a){return[a[0].utc,a[1]]}),_i=Ui.multi([[".%L",function(a){return a.getUTCMilliseconds()}],[":%S",function(a){return a.getUTCSeconds()}],["%I:%M",function(a){return a.getUTCMinutes()}],["%I %p",function(a){return a.getUTCHours()}],["%a %d",function(a){return a.getUTCDay()&&1!=a.getUTCDate()}],["%b %d",function(a){return 1!=a.getUTCDate()}],["%B",function(a){return a.getUTCMonth()}],["%Y",Eb]]);$i.year=kh.year.utc,kh.scale.utc=function(){return eg(ig.scale.linear(),$i,_i)},ig.text=Ca(function(a){return a.responseText}),ig.json=function(a,b){return Da(a,"application/json",gg,b)},ig.html=function(a,b){return Da(a,"text/html",hg,b)},ig.xml=Ca(function(a){return a.responseXML}),"function"==typeof define&&define.amd?(this.d3=ig,define(ig)):"object"==typeof b&&b.exports?b.exports=ig:this.d3=ig}()},{}],26:[function(a,b,c){function d(a,b){return d.semantics.solve(a,b)}b.exports=d,d.semantics={solve:function(a,b){for(;;){for(;this.simplifiers.hasOwnProperty(a.type);){var c=this.simplifiers[a.type](a);if(!c)break;a=c}var d=this.rotateTargetToSource.hasOwnProperty(a.type),e=this.rotateSourceToTarget.hasOwnProperty(b.type);if(!d&&!e)break;d?(b=this.rotateTargetToSource[a.type](a,b),a=a.args[0]):e&&(a=this.rotateSourceToTarget[b.type](a,b),b=b.args[0])}return[a,b]},simplifiers:{not:function(a){var b=a.args[0];if("not"===b.type)return b.args[0]},add:function(a){var b=a.args[0];if("literal"===b.type&&""===b.value)return{type:"toString",args:[a.args[1]]}},someBlock:function(a){return{type:"not",args:[{type:"everyBlock",args:[a.args[0],{type:"not",args:[a.args[1]]}]}]}}},rotateTargetToSource:{reflect:function(a,b){return{type:a.type,args:[b]}},invert:function(a,b,c){return{type:c,args:[b,a.args[1]]}},toNumber:function(a,b){return this.reflect(a,b)},toString:function(a,b){return this.reflect(a,b)},not:function(a,b){return this.reflect(a,b)},neg:function(a,b){return this.reflect(a,b)},add:function(a,b){return this.invert(a,b,"sub")},sub:function(a,b){return this.invert(a,b,"add")},mul:function(a,b){return this.invert(a,b,"div")},div:function(a,b){return this.invert(a,b,"mul")},pow:function(a,b){return this.invert(a,b,"root")},root:function(a,b){return this.invert(a,b,"pow")},join:function(a,b){return this.invert(a,b,"split")},split:function(a,b){return this.invert(a,b,"join")}},rotateSourceToTarget:{rangeContent:function(a,b){return"rangeContent"===a.type?a:{type:b.type,args:[a]}}}}},{}],27:[function(a,b,c){function d(a,b,c){c.target=a,c.targetPath=b;var d=c.source=c.source||a,j=c["<-"]||c["<->"]||"",k=c.twoWay="<->"in c;c.sourcePath=j;var l=(c.value,c.parameters=c.parameters||d),m=c.document,n=c.components,p=c.trace,q=c.sourceScope=new o(d);q.parameters=l,q.document=m,q.components=n;var r=c.targetScope=new o(a);if(r.parameters=l,r.document=m,r.components=n,c.converter){var s=c.converter;s.convert&&(c.convert=s.convert.bind(s)),s.revert&&(c.revert=s.revert.bind(s))}else if(c.reverter){var t=c.reverter;t.convert&&(c.revert=t.convert.bind(t)),t.revert&&(c.convert=t.revert.bind(t))}var u=c.convert,v=c.revert,w=c.sourceSyntax=g(j),x=c.targetSyntax=g(b),y=h(x,w);if(x=y[0],w=y[1],k&&"rangeContent"===x.type)return f(r,x.args[0],q,w,u,v,c,p?{sourcePath:i(w),targetPath:i(x.args[0])}:null);p&&console.log("DEFINE BINDING",b,"<-",j,a);var z=e(r,x,q,w,u,c,p),y=h(w,x);w=y[0],x=y[1];var A=Function.noop;return k&&(p&&console.log("DEFINE BINDING",b,"->",j,d),A=e(q,w,r,x,v,c,p)),function(){z(),A()}}function e(a,b,c,d,e,f,g){var h=j(d);return e&&(h=m.makeConverterObserver(h,e,c)),k(b)(h,c,a,f,g?{sourcePath:i(d),targetPath:i(b)}:null)}function f(a,b,c,d,e,f,g,h){function i(a,b,c){q||(q=!0,
+h&&console.log("RANGE CONTENT PROPAGATED",h.targetPath,"<-",h.sourcePath,"PLUS",a,"MINUS",b,"AT",c),o.swap(c,b.length,a),q=!1)}function k(a,b,c){q||(q=!0,h&&console.log("RANGE CONTENT PROPAGATED",h.targetPath,"->",h.sourcePath,"PLUS",a,"MINUS",b,"AT",c),p.swap(c,b.length,a),q=!1)}function m(){if(p!==o){h&&console.log("RANGE CONTENT BOUND",h.targetPath,"<->",h.sourcePath),q=!0;var b=n(p,i,c),d=n(o,k,a);return q=!1,function(){h&&console.log("RANGE CONTENT UNBOUND",h.targetPath,"<->",h.sourcePath),b(),d()}}}var o,p,q,r=j(d),s=j(b),t=l(d),u=l(b),v=Function.noop;q=!0;var w=s(function(a){v(),v=Function.noop,h&&console.log("RANGE CONTENT TARGET",h.targetPath,"SET TO",a),a&&a.addRangeChangeListener&&(o=a,p&&o?(h&&console.log("RANGE CONTENT TARGET REPLACES SOURCE",h.targetPath,"->",h.sourcePath,"WITH",o),q=!0,p.swap(0,p.length,o),q=!1,v=m()):p||q||(h&&console.log("RANGE CONTENT TARGET INITIALIZED TO COPY OF SOURCE",h.targetPath,"<-",tarce.sourcePath,"WITH",p),t(o.clone(),c)))},a);q=!1;var x=r(function(b){v(),v=Function.noop,h&&console.log("RANGE CONTENT SOURCE",h.sourcePath,"SET TO",b),b&&b.addRangeChangeListener&&(p=b,o&&p?(h&&console.log("RANGE CONTENT SOURCE REPLACES TARGET",h.targetPath,"<-",h.sourcePath,"WITH",p),q=!0,o.swap(0,o.length,p),q=!1,v=m()):o||u(p.clone(),a))},c);return o||p||t([],c),function(){v(),w(),x()}}var g=a("./parse"),h=a("./algebra"),i=a("./stringify"),j=a("./compile-observer"),k=a("./compile-binder"),l=a("./compile-assigner"),m=a("./observers"),n=m.observeRangeChange,o=(a("./binders"),a("./scope"));b.exports=d},{"./algebra":26,"./binders":28,"./compile-assigner":30,"./compile-binder":31,"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66,"./stringify":67}],28:[function(a,b,c){function d(){return new Error("").stack.replace(/^.*\n.*\n/,"\n")}function e(a,b,c,e,f,g){return c(function(c){if(!f.isActive)try{f.isActive=!0,g&&console.log("SET",g.targetPath,"TO",c,"ON",a,"BECAUSE",g.sourcePath,d()),Array.isArray(a)&&b>>>0===b?a.set(b,c):a[b]=c}finally{f.isActive=!1}},e)}function f(a,b){return function(c,d,e,f,g){return b(function(b){if(null!=b)return a(function(a){if(null!=a)return a.bindProperty?a.bindProperty(b,c,d,f,g):H(a,b,c,d,f,g)},e)},e)}}function g(a,b,c,e,f,g){return c(function(c){if(!f.isActive)try{f.isActive=!0,g&&console.log("SET FOR KEY",b,"TO",c,"ON",a,"BECAUSE",g.sourcePath,d()),a.set(b,c)}finally{f.isActive=!1}},e)}function h(a,b){return function(c,d,e,f,g){return a(function(a){if(a)return b(function(b){if(null!=b)return I(a,b,c,d,f,g)},e)},e)}}function i(a,b){return function(c,e,f,g,h){return a(function(a){if(a)return b(function(b){if(null!=b)return c(function(c){if(c)(a.has||a.contains).call(a,b)||(h&&console.log("ADD",b,"TO",h.targetPath,"BECAUSE",h.sourcePath,d()),a.add(b));else for(;(a.has||a.contains).call(a,b);)h&&console.log("REMOVE",b,"FROM",h.targetPath,"BECAUSE",h.sourcePath,d()),(a.remove||a.delete).call(a,b)},e)},f)},f)}}function j(a,b){return function(c,e,f,g,h){return c(function(c){if(c){h&&console.log("BIND",h.targetPath,"TO",h.sourcePath,d());var f=a(b,e,e,g,h)||Function.noop;return function(){f(),h&&console.log("UNBIND",h.targetPath,"FROM",h.sourcePath,d())}}},f)}}function k(a,b,c){return function(d,e,f,g,h){return d(function(d){if(d)return a(function(a){function d(a,d,i){e.swap(i,d.length,a.map(function(a,d){var e=f.nest(a);return b(c,e,e,g,h)}))}if(a){var e=[],i=z(a,d,f)||Function.noop;return function(){A(e),i()}}},f)},e)}}function l(a,b,c,d,e,f){var g=B(d),h=D(c,g);return function(c,d,g,i,j){return c(function(c){if(null!=c){if(c){var d=a(e,F,g,i,j)||Function.noop,k=b(f,F,g,i,j)||Function.noop;return function(){d(),k()}}return a(h,g,g,i,j)}},d)}}function m(a,b,c,d,e,f){var g=B(d),h=C(c,g);return function(c,d,g,i,j){return c(function(c){if(null!=c){if(c)return a(h,g,g,i,j);var d=a(e,G,g,i,j)||Function.noop,k=b(f,G,g,i,j)||Function.noop;return function(){d(),k()}}},d)}}function n(a,b,c){return function(d,e,f,g,h){return a(function(a){if(null!=a)return a?b(d,e,f,g,h):c(d,e,f,g,h)},e)}}function o(a){return function(b,c,d,e,f){return a(function(a){if(a)return b(function(b){null!=b&&(a.splice?a.splice(0,a.length,b):a.clear&&a.add&&(a.clear(),a.add(b)))},c)},d)}}function p(a){return function(b,c,d,e,f){return a(function(a){if(a)return b(function(b){null!=b&&b!==a.one()&&(a.splice?a.splice(0,a.length,b):a.clear&&a.add&&(a.clear(),a.add(b)))},c)},d)}}function q(a,b){return function(c,e,f,g,h){return a(function(a){return a?c(function(b){function c(b,c,e){w(a)||(h&&console.log("SWAPPING",c,"FOR",b,"AT",e,"ON",h.targetPath,d()),a.swap?a.swap(e,c.length,b):a.add&&(a.remove||a.delete)&&(b.forEach(a.add,a),c.forEach(a.remove||a.delete,a)))}if(b!==a){if(!b)return void a.clear();if(b.addRangeChangeListener)return b.addRangeChangeListener(c),c(Array.from(b),Array.from(a),0),function(){b.removeRangeChangeListener(c)}}},e):b(y.makeLiteralObserver([]),e,f,g,h)},f)}}function r(a){return function(b,c,e,f,g){return a(function(a){if(a)return b(function(b){function c(b,c){if(!f.isActive)try{f.isActive=!0,void 0===b?(g&&g&&console.log("DELETED",g.targetPath,"FOR KEY",c,"ON",a,"BECAUSE",g.sourcePath,d()),Array.isArray(a)?a.splice(c,1):a.delete(c)):(g&&g&&console.log("SET",g.targetPath,"FOR KEY",c,"TO",b,"ON",a,"BECAUSE",g.sourcePath,d()),a.set(c,b))}finally{f.isActive=!1}}return b?(a.clear(),b.forEach(c),b.addMapChangeListener(c)):void a.clear()},c)},e)}}function s(a){return function(b,c,d,e,f){return a(function(a){if(a)return b(function(b){function c(b,c,d){if(!w(a)){var e=a.length-d-c.length;a.swap(e,c.length,b.reversed())}}return b?(b.addRangeChangeListener(c),c(b,a,0),function(){b.removeRangeChangeListener(c)}):void a.clear()},c)},d)}}function t(a){return function(b,c,d,e,f){return b(function(b){if(!b)return a(E,c,d,e,f)},d)}}function u(a){return function(b,c,d,e,f){if(d.parent)return a(b,c,d.parent,e,f)}}function v(a,b){return function(c,d,e,f,g){return a(function(a){if(null!=a)return b(c,d,e.nest(a),f,g)},e)}}function w(a){return a.getRangeChangeDescriptor&&a.getRangeChangeDescriptor().isActive}var x=a("./scope"),y=a("./observers"),z=y.observeRangeChange,A=y.cancelEach,B=y.makeNotObserver,C=y.makeOrObserver,D=y.makeAndObserver,E=(y.observeValue,y.makeLiteralObserver()),F=new x(!0),G=new x(!1);c.bindProperty=e;var H=e;c.makePropertyBinder=f,c.bindGet=g;var I=g;c.makeGetBinder=h,c.makeHasBinder=i,c.makeEqualityBinder=j,c.makeEveryBlockBinder=k,c.makeAndBinder=l,c.makeOrBinder=m,c.makeConditionalBinder=n,c.makeOnlyBinder=o,c.makeOneBinder=p,c.makeRangeContentBinder=q,c.makeMapContentBinder=r,c.makeReversedBinder=s,c.makeDefinedBinder=t,c.makeParentBinder=u,c.makeWithBinder=v},{"./observers":63,"./scope":66}],29:[function(a,b,c){function d(a,b,c){if(b)for(var d in b)e(a,d,b[d],c);return a}function e(a,b,d,e){e=e||Object.empty;var g=f(a);if(n.call(g,b))throw new Error("Can't bind to already bound target, "+JSON.stringify(b));return"<-"in d||"<->"in d||"compute"in d?(d.target=a,d.parameters=d.parameters||e.parameters,d.document=d.document||e.document,d.components=d.components||e.components,d.cancel="compute"in d?l(a,b,d):k(a,b,d),g[b]=d,c.count++):("get"in d||"set"in d||"writable"in d||(d.writable=!0),"configurable"in d||(d.configurable=!0),"enumerable"in d||(d.enumerable=!0),Object.defineProperty(a,b,d)),a}function f(a){return m.has(a)||m.set(a,{}),m.get(a)}function g(a,b){return f(a)[b]}function h(a){var b=f(a);for(var c in b)i(a,c)}function i(a,b){var d=f(a);if(!d[b])throw new Error("Can't cancel non-existent binding to "+JSON.stringify(b));var e=d[b];if(e&&e.cancel){e.cancel(),delete d[b],c.count--;for(var b in d)return;m.delete(a)}}var j=a("collections/map"),k=a("./bind"),l=a("./compute"),m=(a("./observe"),a("./stringify"),new j),n=Object.prototype.hasOwnProperty;c.count=0,c.bindings=m,c.defineBindings=d,c.defineBinding=e,c.getBindings=f,c.getBinding=g,c.cancelBindings=h,c.cancelBinding=i},{"./bind":27,"./compute":34,"./observe":62,"./stringify":67,"collections/map":51}],30:[function(a,b,c){function d(a){return d.semantics.compile(a)}var e=a("./compile-evaluator"),f=a("./algebra"),g=(a("./scope"),{type:"value"}),h={type:"literal",value:!0},i={type:"literal",value:!1};b.exports=d,d.semantics={compile:function(a){var b=this.compilers;if("equals"===a.type){var c=this.compile(a.args[0]),d=this.compileEvaluator(a.args[1]);return b.equals(c,d)}if("if"===a.type){var e=this.compileEvaluator(a.args[0]),h=this.compile(a.args[1]),i=this.compile(a.args[2]);return b.if(e,h,i)}if("and"===a.type||"or"===a.type){var j=f(a.args[0],g),k=f(a.args[1],g),l=this.compileEvaluator(a.args[0]),d=this.compileEvaluator(a.args[1]),m=this.compileEvaluator(j[1]),n=this.compileEvaluator(k[1]),c=this.compile(j[0]),o=this.compile(k[0]);return b[a.type](c,o,l,d,m,n)}if("everyBlock"===a.type){var p=this.compileEvaluator(a.args[0]),q=f(a.args[1],{type:"literal",value:!0}),r=this.compile(q[0]),s=this.compileEvaluator(q[1]);return b.everyBlock(p,r,s)}if("parent"===a.type){var t=this.compile(a.args[0]);return function(a,b){return t(a,b.parent)}}if(b.hasOwnProperty(a.type)){var u=a.args.map(this.compileEvaluator,this.compileEvaluator.semantics);return b[a.type].apply(null,u)}throw new Error("Can't compile assigner for "+JSON.stringify(a.type))},compileEvaluator:e,compilers:{property:function(a,b){return function(c,d){var e=a(d);if(e){var f=b(d);null!=f&&(Array.isArray(e)?e.set(f,c):e[f]=c)}}},get:function(a,b){return function(c,d){var e=a(d);if(e){var f=b(d);null!=f&&e.set(f,c)}}},has:function(a,b){return function(c,d){var e=a(d);if(e){var f=b(d);null!=c&&(c?(e.has||e.contains).call(e,f)||e.add(f):(e.has||e.contains).call(e,f)&&(e.remove||e.delete).call(e,f))}}},equals:function(a,b){return function(c,d){if(c)return a(b(d),d)}},if:function(a,b,c){return function(d,e){var f=a(e);if(null!=f)return f?b(d,e):c(d,e)}},and:function(a,b,c,d,e,f){return function(g,i){null!=g&&(g?(a(e(h),i),b(f(h),i)):a(c(i)&&!d(i),i))}},or:function(a,b,c,d,e,f){return function(g,h){null!=g&&(g?a(c(h)||!d(h),h):(a(e(i),h),b(f(i),h)))}},rangeContent:function(a){return function(b,c){var d=a(c);d&&(b?d.swap(0,d.length,b):d.clear())}},mapContent:function(a){return function(b,c){var d=a(c);d&&(d.clear(),c.value&&d.addEach(b))}},reversed:function(a){return function(b,c){var d=a(c);d&&d.swap(0,d.length,b.reversed())}},everyBlock:function(a,b,c){return function(d,e){if(d){var f=a(e),g=c(e);f.forEach(function(a){b(g,e.nest(a))})}}}}}},{"./algebra":26,"./compile-evaluator":32,"./scope":66}],31:[function(a,b,c){function d(a){return d.semantics.compile(a)}var e=a("./compile-observer"),f=(a("./observers"),a("./binders")),g=a("./algebra"),h={type:"value"},i={type:"literal",value:!0};b.exports=d,d.semantics={compilers:{property:f.makePropertyBinder,get:f.makeGetBinder,has:f.makeHasBinder,only:f.makeOnlyBinder,one:f.makeOneBinder,rangeContent:f.makeRangeContentBinder,mapContent:f.makeMapContentBinder,reversed:f.makeReversedBinder,and:f.makeAndBinder,or:f.makeOrBinder},compile:function(a){var b=this.compilers;if("default"===a.type)return this.compile(a.args[0]);if("literal"===a.type){if(null==a.value)return Function.noop;throw new Error("Can't bind to literal: "+a.value)}if("equals"===a.type){var c=this.compile(a.args[0]),d=e(a.args[1]);return f.makeEqualityBinder(c,d)}if("if"===a.type){var j=e(a.args[0]),k=this.compile(a.args[1]),l=this.compile(a.args[2]);return f.makeConditionalBinder(j,k,l)}if("and"===a.type||"or"===a.type){var m=g(a.args[0],h),n=g(a.args[1],h),c=this.compile(m[0]),o=this.compile(n[0]),p=e(m[1]),q=e(n[1]),r=e(a.args[0]),d=e(a.args[1]);return this.compilers[a.type](c,o,r,d,p,q)}if("everyBlock"===a.type){var s=e(a.args[0]),t=g(a.args[1],i),u=this.compile(t[0]),v=e(t[1]);return f.makeEveryBlockBinder(s,u,v)}if("rangeContent"===a.type){var w,x=e(a.args[0]);try{w=this.compile(a.args[0])}catch(a){w=Function.noop}return f.makeRangeContentBinder(x,w)}if("defined"===a.type){var w=this.compile(a.args[0]);return f.makeDefinedBinder(w)}if("parent"===a.type){var w=this.compile(a.args[0]);return f.makeParentBinder(w)}if("with"===a.type){var x=e(a.args[0]),w=this.compile(a.args[1]);return f.makeWithBinder(x,w)}if(b.hasOwnProperty(a.type)){var y=a.args.map(e,e.semantics);return b[a.type].apply(null,y)}throw new Error("Can't compile binder for "+JSON.stringify(a.type))}}},{"./algebra":26,"./binders":28,"./compile-observer":33,"./observers":63}],32:[function(a,b,c){function d(a){return d.semantics.compile(a)}var e=a("collections/shim-object"),f=a("collections/map"),g=a("collections/sorted-set"),h=a("./operators");a("./scope");b.exports=d;var i={literal:function(a){return function(){return a.value}},value:function(a){return function(a){return a.value}},parameters:function(a){return function(a){return a.parameters}},element:function(a){return function(b){return b.document.getElementById(a.id)}},component:function(a){return function(b){return b.components.getObjectByLabel(a.label)}},tuple:function(a){var b=a.args.map(this.compile,this);return function(a){return b.map(function(b){return b(a)})}},record:function(a){var b=a.args,c={};for(var d in b)c[d]=this.compile(b[d]);return function(a){var b={};for(var d in c)b[d]=c[d](a);return b}}},j={mapBlock:function(a,b){return function(c){return a(c).map(function(a){return b(c.nest(a))})}},filterBlock:function(a,b){return function(c){return a(c).filter(function(a){return b(c.nest(a))})}},someBlock:function(a,b){return function(c){return a(c).some(function(a){return b(c.nest(a))})}},everyBlock:function(a,b){return function(c){return a(c).every(function(a){return b(c.nest(a))})}},sortedBlock:function(a,b){return function(c){return a(c).sorted(Function.by(function(a){return b(c.nest(a))}))}},sortedSetBlock:function(a,b){return function(c){function d(a){return b(c.nest(a))}function f(a,b){return e.compare(d(a),d(b))}function h(a,b){return e.equals(d(a),d(b))}return new g(a(c),h,f)}},groupBlock:function(a,b){return function(c){return a(c).group(function(a){return b(c.nest(a))})}},groupMapBlock:function(a,b){return function(c){return new f(a(c).group(function(a){return b(c.nest(a))}))}},minBlock:function(a,b){return function(c){return a(c).min(Function.by(function(a){return b(c.nest(a))}))}},maxBlock:function(a,b){return function(c){return a(c).max(Function.by(function(a){return b(c.nest(a))}))}},parent:function(a){return function(b){return a(b.parent)}},with:function(a,b){return function(c){return b(c.nest(a(c)))}},if:function(a,b,c){return function(d){var e=a(d);if(null!=e)return e?b(d):c(d)}},not:function(a){return function(b){return!a(b)}},and:function(a,b){return function(c){return a(c)&&b(c)}},or:function(a,b){return function(c){return a(c)||b(c)}},default:function(a,b){return function(c){var d=a(c);return null==d&&(d=b(c)),d}},defined:function(a){return function(b){return null!=a(b)}},path:function(b,c){return function(e){var f=b(e),g=c(e),h=a("./parse");try{return d(h(g))(e.nest(f))}catch(a){}}}},k=e.clone(h,1);e.addEach(k,{property:function(a,b){return a[b]},get:function(a,b){return a.get(b)},mapContent:Function.identity,rangeContent:Function.identity,view:function(a,b,c){return a.slice(b,b+c)}});d.semantics={compilers:i,argCompilers:j,operators:k,compile:function(a){var b=this.compilers,c=this.argCompilers,d=this.operators;if(b.hasOwnProperty(a.type))return b[a.type].call(this,a);if(c.hasOwnProperty(a.type)){var e=a.args.map(this.compile,this);return c[a.type].apply(null,e)}d.hasOwnProperty(a.type)||(d[a.type]=function(b){var c=Array.prototype.slice.call(arguments,1);if(!b[a.type])throw new TypeError("Can't call "+JSON.stringify(a.type)+" of "+b);return b[a.type].apply(b,c)});var f=d[a.type],e=a.args.map(this.compile,this);return function(a){var b=e.map(function(b){return b(a)});if(b.every(h.defined))return f.apply(null,b)}}}},{"./operators":64,"./parse":65,"./scope":66,"collections/map":51,"collections/shim-object":56,"collections/sorted-set":60}],33:[function(a,b,c){function d(a){return g.compile(a)}var e=a("./observers"),f=a("./operators");b.exports=d;var g=d.semantics={compilers:{property:e.makePropertyObserver,get:e.makeGetObserver,path:e.makePathObserver,with:e.makeWithObserver,if:e.makeConditionalObserver,parent:e.makeParentObserver,not:e.makeNotObserver,and:e.makeAndObserver,or:e.makeOrObserver,default:e.makeDefaultObserver,defined:e.makeDefinedObserver,rangeContent:Function.identity,mapContent:Function.identity,keys:e.makeKeysObserver,values:e.makeValuesObserver,items:e.makeEntriesObserver,entries:e.makeEntriesObserver,toMap:e.makeToMapObserver,mapBlock:e.makeMapBlockObserver,filterBlock:e.makeFilterBlockObserver,everyBlock:e.makeEveryBlockObserver,someBlock:e.makeSomeBlockObserver,sortedBlock:e.makeSortedBlockObserver,sortedSetBlock:e.makeSortedSetBlockObserver,groupBlock:e.makeGroupBlockObserver,groupMapBlock:e.makeGroupMapBlockObserver,minBlock:e.makeMinBlockObserver,maxBlock:e.makeMaxBlockObserver,min:e.makeMinObserver,max:e.makeMaxObserver,enumerate:e.makeEnumerationObserver,reversed:e.makeReversedObserver,flatten:e.makeFlattenObserver,concat:e.makeConcatObserver,view:e.makeViewObserver,sum:e.makeSumObserver,average:e.makeAverageObserver,last:e.makeLastObserver,only:e.makeOnlyObserver,one:e.makeOneObserver,has:e.makeHasObserver,tuple:e.makeArrayObserver,range:e.makeRangeObserver,startsWith:e.makeStartsWithObserver,endsWith:e.makeEndsWithObserver,contains:e.makeContainsObserver,join:e.makeJoinObserver,toArray:e.makeToArrayObserver,asArray:e.makeToArrayObserver},compile:function(a){var b=this.compilers;if("literal"===a.type)return e.makeLiteralObserver(a.value);if("value"===a.type)return e.observeValue;if("parameters"===a.type)return e.observeParameters;if("element"===a.type)return e.makeElementObserver(a.id);if("component"===a.type)return e.makeComponentObserver(a.label,a);if("record"===a.type){var c={},d=a.args;for(var f in d)c[f]=this.compile(d[f]);return e.makeObjectObserver(c)}b.hasOwnProperty(a.type)||(b[a.type]=e.makeMethodObserverMaker(a.type));var g=a.args.map(this.compile,this);return b[a.type].apply(null,g)}},h=g.compilers;Object.keys(f).forEach(function(a){h[a]||(h[a]=e.makeOperatorObserverMaker(f[a]))}),h.toString=e.makeOperatorObserverMaker(f.toString)},{"./observers":63,"./operators":64}],34:[function(a,b,c){function d(a,b,c){c.target=a,c.targetPath=b;var d=c.source=c.source||a,j=c.args,k=c.compute,l=c.parameters=c.parameters||d,m=c.document,n=c.components,o=c.trace,p=c.sourceScope=new i(d);p.parameters=l,p.document=m,p.components=n;var q=c.targetScope=new i(a);q.parameters=l,q.document=m,q.components=n;var r=j.map(function(a){return e(a)}).map(function(a){if("rangeContent"===a.type){var b=f(a.args[0]);return h.makeRangeContentObserver(b)}if("mapContent"===a.type){var b=f(a.args[0]);return h.makeMapContentObserver(b)}return f(a)}),s=h.makeRangeContentObserver(h.makeObserversObserver(r)),t=h.makeComputerObserver(s,k,a);return g(e(b))(t,p,q,c,o?{sourcePath:j.join(", "),targetPath:b}:void 0)}var e=a("./parse"),f=a("./compile-observer"),g=a("./compile-binder"),h=a("./observers"),i=a("./scope");b.exports=d},{"./compile-binder":31,"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66}],35:[function(a,b,c){function d(a){i.dispatchOwnPropertyChange(a.target,"checked",a.target.checked)}function e(a){i.dispatchOwnPropertyChange(a.target,"value",a.target.value)}function f(a){i.dispatchOwnPropertyChange(a.target,"innerHTML",a.target.innerHTML),i.dispatchOwnPropertyChange(a.target,"innerText",a.target.innerText),i.dispatchOwnPropertyChange(a.target,"value",a.target.innerText)}function g(a){"checked"===a?this.addEventListener("change",d):"value"===a&&(this.addEventListener("change",e),"text"===this.type||"TEXTAREA"===this.nodeName?this.addEventListener("keyup",e):this.contentEditable&&(this.innerText=this.innerText?this.innerText:this.value,this.addEventListener("keyup",f)))}function h(a){"checked"===a?this.removeEventListener("change",d):"value"===a&&(this.removeEventListener("change",e),"text"===this.type||"TEXTAREA"===this.nodeName?this.removeEventListener("keyup",e):this.contentEditable&&this.removeEventListener("keyup",f))}var i=a("collections/listen/property-changes"),j=Object.getPrototypeOf(document.createElement("input"));j.makePropertyObservable=g,j.makePropertyUnobservable=h;var k=Object.getPrototypeOf(document.createElement("textarea"));k.makePropertyObservable=g,k.makePropertyUnobservable=h;var l=Object.getPrototypeOf(document.createElement("span"));l.makePropertyObservable=g,l.makePropertyUnobservable=h},{"collections/listen/property-changes":49}],36:[function(a,b,c){b.exports=function(){function a(a,b,c,d,e){this.expected=a,this.found=b,this.offset=c,this.line=d,this.column=e,this.name="SyntaxError",this.message=function(a,b){var c,d;switch(a.length){case 0:c="end of input";break;case 1:c=a[0];break;default:c=a.slice(0,-1).join(", ")+" or "+a[a.length-1]}return d=b?'"'+function(a){function b(a){return a.charCodeAt(0).toString(16).toUpperCase()}return a.replace(/\\/g,"\\\\").replace(/"/g,'\\"').replace(/\x08/g,"\\b").replace(/\t/g,"\\t").replace(/\n/g,"\\n").replace(/\f/g,"\\f").replace(/\r/g,"\\r").replace(/[\x00-\x07\x0B\x0E\x0F]/g,function(a){return"\\x0"+b(a)}).replace(/[\x10-\x1F\x80-\xFF]/g,function(a){return"\\x"+b(a)}).replace(/[\u0180-\u0FFF]/g,function(a){return"\\u0"+b(a)}).replace(/[\u1080-\uFFFF]/g,function(a){return"\\u"+b(a)})}(b)+'"':"end of input","Expected "+c+" but "+d+" found."}(a,b)}function b(b){function c(a){return Rd!==a&&(Rd>a&&(Rd=0,Sd={line:1,column:1,seenCR:!1}),function(a,c,d){var e,f;for(e=c;e<d;e++)f=b.charAt(e),"\n"===f?(a.seenCR||a.line++,a.column=1,a.seenCR=!1):"\r"===f||"\u2028"===f||"\u2029"===f?(a.line++,a.column=1,a.seenCR=!0):(a.column++,a.seenCR=!1)}(Sd,Rd,a),Rd=a),Sd}function d(a){Pd<Td||(Pd>Td&&(Td=Pd,Ud=[]),Ud.push(a))}function e(){var a;return Vd++,a=h(),Vd--,null===a&&(null,0===Vd&&d($)),a}function f(){var a,c,f,g,h,i,j;if(a=Pd,null!==(c=e())){for(f=[],g=Pd,44===b.charCodeAt(Pd)?(h=aa,Pd++):(h=null,0===Vd&&d(ba)),null!==h?(i=N(),null!==i?(j=e(),null!==j?(h=[h,i,j],g=h):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_);null!==g;)f.push(g),g=Pd,44===b.charCodeAt(Pd)?(h=aa,Pd++):(h=null,0===Vd&&d(ba)),null!==h?(i=N(),null!==i?(j=e(),null!==j?(h=[h,i,j],g=h):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_);null!==f?(Qd=a,c=ca(c,f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function g(){var a,c,e,g;return a=Pd,40===b.charCodeAt(Pd)?(c=da,Pd++):(c=null,0===Vd&&d(ea)),null!==c?(e=N(),null!==e?(41===b.charCodeAt(Pd)?(g=fa,Pd++):(g=null,0===Vd&&d(ga)),null!==g?(Qd=a,c=ha(),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,40===b.charCodeAt(Pd)?(c=da,Pd++):(c=null,0===Vd&&d(ea)),null!==c?(e=f(),null!==e?(41===b.charCodeAt(Pd)?(g=fa,Pd++):(g=null,0===Vd&&d(ga)),null!==g?(Qd=a,c=ia(e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)),a}function h(){var a,c,f,g,h,j,k,l,m,n,o;return a=Pd,c=i(),null!==c?(f=N(),null!==f?(g=Pd,63===b.charCodeAt(Pd)?(h=ka,Pd++):(h=null,0===Vd&&d(la)),null!==h?(j=N(),null!==j?(k=e(),null!==k?(l=N(),null!==l?(58===b.charCodeAt(Pd)?(m=ma,Pd++):(m=null,0===Vd&&d(na)),null!==m?(n=N(),null!==n?(o=e(),null!==o?(h=[h,j,k,l,m,n,o],g=h):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_),null===g&&(g=ja),null!==g?(Qd=a,c=oa(c,g),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),a}function i(){var a,c,e,f,g,h,i,k;if(a=Pd,null!==(c=j())){for(e=[],f=Pd,g=N(),null!==g?(b.substr(Pd,2)===pa?(h=pa,Pd+=2):(h=null,0===Vd&&d(qa)),null!==h?(i=N(),null!==i?(k=j(),null!==k?(g=[g,h,i,k],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(b.substr(Pd,2)===pa?(h=pa,Pd+=2):(h=null,0===Vd&&d(qa)),null!==h?(i=N(),null!==i?(k=j(),null!==k?(g=[g,h,i,k],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function j(){var a,c,e,f,g,h,i,j;if(a=Pd,null!==(c=k())){for(e=[],f=Pd,g=N(),null!==g?(b.substr(Pd,2)===sa?(h=sa,Pd+=2):(h=null,0===Vd&&d(ta)),null!==h?(i=N(),null!==i?(j=k(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(b.substr(Pd,2)===sa?(h=sa,Pd+=2):(h=null,0===Vd&&d(ta)),null!==h?(i=N(),null!==i?(j=k(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function k(){var a,c,e,f,g,h,i,j,k;return a=Pd,c=l(),null!==c?(e=Pd,f=N(),null!==f?(g=Pd,b.substr(Pd,3)===ua?(h=ua,Pd+=3):(h=null,0===Vd&&d(va)),null===h&&(b.substr(Pd,2)===wa?(h=wa,Pd+=2):(h=null,0===Vd&&d(xa)),null===h&&(b.substr(Pd,2)===ya?(h=ya,Pd+=2):(h=null,0===Vd&&d(za)),null===h&&(h=Pd,60===b.charCodeAt(Pd)?(i=Aa,Pd++):(i=null,0===Vd&&d(Ba)),null!==i?(j=Pd,Vd++,45===b.charCodeAt(Pd)?(k=Ca,Pd++):(k=null,0===Vd&&d(Da)),Vd--,null===k?j=ja:(Pd=j,j=_),null!==j?(i=[i,j],h=i):(Pd=h,h=_)):(Pd=h,h=_),null===h&&(62===b.charCodeAt(Pd)?(h=Ea,Pd++):(h=null,0===Vd&&d(Fa)),null===h&&(b.substr(Pd,2)===Ga?(h=Ga,Pd+=2):(h=null,0===Vd&&d(Ha)),null===h&&(b.substr(Pd,2)===Ia?(h=Ia,Pd+=2):(h=null,0===Vd&&d(Ja)))))))),null!==h&&(h=b.substring(g,Pd)),g=h,null!==g?(h=N(),null!==h?(i=l(),null!==i?(f=[f,g,h,i],e=f):(Pd=e,e=_)):(Pd=e,e=_)):(Pd=e,e=_)):(Pd=e,e=_),null===e&&(e=ja),null!==e?(Qd=a,c=Ka(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),a}function l(){var a,c,e,f,g,h,i,j;if(a=Pd,null!==(c=m())){for(e=[],f=Pd,g=N(),null!==g?(h=Pd,43===b.charCodeAt(Pd)?(i=La,Pd++):(i=null,0===Vd&&d(Ma)),null===i&&(45===b.charCodeAt(Pd)?(i=Ca,Pd++):(i=null,0===Vd&&d(Da))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=m(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(h=Pd,43===b.charCodeAt(Pd)?(i=La,Pd++):(i=null,0===Vd&&d(Ma)),null===i&&(45===b.charCodeAt(Pd)?(i=Ca,Pd++):(i=null,0===Vd&&d(Da))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=m(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function m(){var a,c,e,f,g,h,i,j;if(a=Pd,null!==(c=n())){for(e=[],f=Pd,g=N(),null!==g?(h=Pd,42===b.charCodeAt(Pd)?(i=Na,Pd++):(i=null,0===Vd&&d(Oa)),null===i&&(47===b.charCodeAt(Pd)?(i=Pa,Pd++):(i=null,0===Vd&&d(Qa)),null===i&&(37===b.charCodeAt(Pd)?(i=Ra,Pd++):(i=null,0===Vd&&d(Sa)),null===i&&(b.substr(Pd,3)===Ta?(i=Ta,Pd+=3):(i=null,0===Vd&&d(Ua))))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=n(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(h=Pd,42===b.charCodeAt(Pd)?(i=Na,Pd++):(i=null,0===Vd&&d(Oa)),null===i&&(47===b.charCodeAt(Pd)?(i=Pa,Pd++):(i=null,0===Vd&&d(Qa)),null===i&&(37===b.charCodeAt(Pd)?(i=Ra,Pd++):(i=null,0===Vd&&d(Sa)),null===i&&(b.substr(Pd,3)===Ta?(i=Ta,Pd+=3):(i=null,0===Vd&&d(Ua))))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=n(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function n(){var a,c,e,f,g,h,i,j;if(a=Pd,null!==(c=o())){for(e=[],f=Pd,g=N(),null!==g?(h=Pd,b.substr(Pd,2)===Va?(i=Va,Pd+=2):(i=null,0===Vd&&d(Wa)),null===i&&(b.substr(Pd,2)===Xa?(i=Xa,Pd+=2):(i=null,0===Vd&&d(Ya)),null===i&&(b.substr(Pd,2)===Za?(i=Za,Pd+=2):(i=null,0===Vd&&d($a)))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=o(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(h=Pd,b.substr(Pd,2)===Va?(i=Va,Pd+=2):(i=null,0===Vd&&d(Wa)),null===i&&(b.substr(Pd,2)===Xa?(i=Xa,Pd+=2):(i=null,0===Vd&&d(Ya)),null===i&&(b.substr(Pd,2)===Za?(i=Za,Pd+=2):(i=null,0===Vd&&d($a)))),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(j=o(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function o(){var a,c,e,f,g,h,i,j;if(a=Pd,null!==(c=p())){for(e=[],f=Pd,g=N(),null!==g?(b.substr(Pd,2)===_a?(h=_a,Pd+=2):(h=null,0===Vd&&d(ab)),null!==h?(i=N(),null!==i?(j=p(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,g=N(),null!==g?(b.substr(Pd,2)===_a?(h=_a,Pd+=2):(h=null,0===Vd&&d(ab)),null!==h?(i=N(),null!==i?(j=p(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=ra(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function p(){var a,c,e;return a=Pd,c=Pd,33===b.charCodeAt(Pd)?(e=bb,Pd++):(e=null,0===Vd&&d(cb)),null===e&&(43===b.charCodeAt(Pd)?(e=La,Pd++):(e=null,0===Vd&&d(Ma)),null===e&&(45===b.charCodeAt(Pd)?(e=Ca,Pd++):(e=null,0===Vd&&d(Da)))),null!==e&&(e=b.substring(c,Pd)),c=e,null!==c?(e=p(),null!==e?(Qd=a,c=db(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=q()),a}function q(){var a,b,c,d;if(a=Pd,null!==(b=t())){for(c=[],d=r();null!==d;)c.push(d),d=r();null!==c?(Qd=a,b=eb(b,c),null===b?(Pd=a,a=b):a=b):(Pd=a,a=_)}else Pd=a,a=_;return a}function r(){var a,c,f,g;return a=Pd,46===b.charCodeAt(Pd)?(c=fb,Pd++):(c=null,0===Vd&&d(gb)),null!==c?(f=s(),null!==f?(Qd=a,c=hb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,91===b.charCodeAt(Pd)?(c=ib,Pd++):(c=null,0===Vd&&d(jb)),null!==c?(f=e(),null!==f?(93===b.charCodeAt(Pd)?(g=kb,Pd++):(g=null,0===Vd&&d(lb)),null!==g?(Qd=a,c=mb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)),a}function s(){var a,c,f,h,i;return a=Pd,c=Pd,f=u(),null!==f&&(f=b.substring(c,Pd)),c=f,null!==c?(123===b.charCodeAt(Pd)?(f=nb,Pd++):(f=null,0===Vd&&d(ob)),null!==f?(h=e(),null!==h?(125===b.charCodeAt(Pd)?(i=pb,Pd++):(i=null,0===Vd&&d(qb)),null!==i?(Qd=a,c=rb(c,h),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,c=Pd,f=u(),null!==f&&(f=b.substring(c,Pd)),c=f,null!==c?(f=g(),null!==f?(Qd=a,c=sb(c,f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,c=J(),null!==c&&(Qd=a,c=tb(c)),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,c=Pd,f=u(),null!==f&&(f=b.substring(c,Pd)),c=f,null!==c&&(Qd=a,c=ub(c)),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,c=A(),null!==c&&(Qd=a,c=vb(c)),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,c=B(),null!==c&&(Qd=a,c=vb(c)),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,40===b.charCodeAt(Pd)?(c=da,Pd++):(c=null,0===Vd&&d(ea)),null!==c?(f=e(),null!==f?(41===b.charCodeAt(Pd)?(h=fa,Pd++):(h=null,0===Vd&&d(ga)),null!==h?(Qd=a,c=vb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_))))))),a}function t(){var a,c,f,h;return a=A(),null===a&&null===(a=B())&&null===(a=v())&&null===(a=E())&&(a=Pd,b.substr(Pd,4)===wb?(c=wb,Pd+=4):(c=null,0===Vd&&d(xb)),null!==c&&(Qd=a,c=yb()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,4)===zb?(c=zb,Pd+=4):(c=null,0===Vd&&d(Ab)),null!==c&&(Qd=a,c=Bb()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,5)===Cb?(c=Cb,Pd+=5):(c=null,0===Vd&&d(Db)),null!==c&&(Qd=a,c=Eb()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,4)===Fb?(c=Fb,Pd+=4):(c=null,0===Vd&&d(Gb)),null!==c&&(Qd=a,c=Hb()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,64===b.charCodeAt(Pd)?(c=Ib,Pd++):(c=null,0===Vd&&d(Jb)),null!==c?(f=Pd,h=T(),null!==h&&(h=b.substring(f,Pd)),f=h,null!==f?(Qd=a,c=Kb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,36===b.charCodeAt(Pd)?(c=Lb,Pd++):(c=null,0===Vd&&d(Mb)),null!==c?(f=Pd,h=u(),null!==h&&(h=b.substring(f,Pd)),f=h,null!==f?(Qd=a,c=Nb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,36===b.charCodeAt(Pd)?(c=Lb,Pd++):(c=null,0===Vd&&d(Mb)),null!==c&&(Qd=a,c=Ob()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,35===b.charCodeAt(Pd)?(c=Pb,Pd++):(c=null,0===Vd&&d(Qb)),null!==c?(f=Pd,h=u(),null!==h&&(h=b.substring(f,Pd)),f=h,null!==f?(Qd=a,c=Rb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,38===b.charCodeAt(Pd)?(c=Sb,Pd++):(c=null,0===Vd&&d(Tb)),null!==c?(f=Pd,h=u(),null!==h&&(h=b.substring(f,Pd)),f=h,null!==f?(h=g(),
+null!==h?(Qd=a,c=Ub(f,h),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,94===b.charCodeAt(Pd)?(c=Vb,Pd++):(c=null,0===Vd&&d(Wb)),null!==c?(f=t(),null!==f?(Qd=a,c=Xb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,40===b.charCodeAt(Pd)?(c=da,Pd++):(c=null,0===Vd&&d(ea)),null!==c?(f=e(),null!==f?(41===b.charCodeAt(Pd)?(h=fa,Pd++):(h=null,0===Vd&&d(ga)),null!==h?(Qd=a,c=Yb(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,c=s(),null!==c&&(Qd=a,c=Zb(c)),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,c=[],null!==c&&(Qd=a,c=$b()),null===c?(Pd=a,a=c):a=c))))))))))))),a}function u(){var a,c;if(Vd++,a=[],ac.test(b.charAt(Pd))?(c=b.charAt(Pd),Pd++):(c=null,0===Vd&&d(bc)),null!==c)for(;null!==c;)a.push(c),ac.test(b.charAt(Pd))?(c=b.charAt(Pd),Pd++):(c=null,0===Vd&&d(bc));else a=_;return Vd--,null===a&&(c=null,0===Vd&&d(_b)),a}function v(){var a,c,e,f;if(Vd++,a=Pd,39===b.charCodeAt(Pd)?(c=dc,Pd++):(c=null,0===Vd&&d(ec)),null!==c){for(e=[],f=w();null!==f;)e.push(f),f=w();null!==e?(39===b.charCodeAt(Pd)?(f=dc,Pd++):(f=null,0===Vd&&d(ec)),null!==f?(Qd=a,c=fc(e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)}else Pd=a,a=_;if(null===a)if(a=Pd,34===b.charCodeAt(Pd)?(c=gc,Pd++):(c=null,0===Vd&&d(hc)),null!==c){for(e=[],f=x();null!==f;)e.push(f),f=x();null!==e?(34===b.charCodeAt(Pd)?(f=gc,Pd++):(f=null,0===Vd&&d(hc)),null!==f?(Qd=a,c=fc(e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)}else Pd=a,a=_;return Vd--,null===a&&(c=null,0===Vd&&d(cc)),a}function w(){var a,c;return ic.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(jc)),null===a&&(a=Pd,b.substr(Pd,2)===kc?(c=kc,Pd+=2):(c=null,0===Vd&&d(lc)),null!==c&&(Qd=a,c=mc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=y())),a}function x(){var a,c;return nc.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(oc)),null===a&&(a=Pd,b.substr(Pd,2)===pc?(c=pc,Pd+=2):(c=null,0===Vd&&d(qc)),null!==c&&(Qd=a,c=rc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=y())),a}function y(){var a,c,e,f,g,h,i,j;return a=Pd,b.substr(Pd,2)===sc?(c=sc,Pd+=2):(c=null,0===Vd&&d(tc)),null!==c&&(Qd=a,c=uc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===vc?(c=vc,Pd+=2):(c=null,0===Vd&&d(wc)),null!==c&&(Qd=a,c=xc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===yc?(c=yc,Pd+=2):(c=null,0===Vd&&d(zc)),null!==c&&(Qd=a,c=Ac()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Bc?(c=Bc,Pd+=2):(c=null,0===Vd&&d(Cc)),null!==c&&(Qd=a,c=Dc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Ec?(c=Ec,Pd+=2):(c=null,0===Vd&&d(Fc)),null!==c&&(Qd=a,c=Gc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Hc?(c=Hc,Pd+=2):(c=null,0===Vd&&d(Ic)),null!==c&&(Qd=a,c=Jc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Kc?(c=Kc,Pd+=2):(c=null,0===Vd&&d(Lc)),null!==c&&(Qd=a,c=Mc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Nc?(c=Nc,Pd+=2):(c=null,0===Vd&&d(Oc)),null!==c&&(Qd=a,c=Pc()),null===c?(Pd=a,a=c):a=c,null===a&&(a=Pd,b.substr(Pd,2)===Qc?(c=Qc,Pd+=2):(c=null,0===Vd&&d(Rc)),null!==c?(e=Pd,f=Pd,g=z(),null!==g?(h=z(),null!==h?(i=z(),null!==i?(j=z(),null!==j?(g=[g,h,i,j],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_),null!==f&&(f=b.substring(e,Pd)),e=f,null!==e?(Qd=a,c=Sc(e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_))))))))),a}function z(){var a;return Tc.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(Uc)),a}function A(){var a,c,e,g;return a=Pd,91===b.charCodeAt(Pd)?(c=ib,Pd++):(c=null,0===Vd&&d(jb)),null!==c?(e=N(),null!==e?(93===b.charCodeAt(Pd)?(g=kb,Pd++):(g=null,0===Vd&&d(lb)),null!==g?(Qd=a,c=Vc(),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,91===b.charCodeAt(Pd)?(c=ib,Pd++):(c=null,0===Vd&&d(jb)),null!==c?(e=f(),null!==e?(93===b.charCodeAt(Pd)?(g=kb,Pd++):(g=null,0===Vd&&d(lb)),null!==g?(Qd=a,c=Wc(e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)),a}function B(){var a,c,e,f,g,h;return a=Pd,123===b.charCodeAt(Pd)?(c=nb,Pd++):(c=null,0===Vd&&d(ob)),null!==c?(e=N(),null!==e?(125===b.charCodeAt(Pd)?(f=pb,Pd++):(f=null,0===Vd&&d(qb)),null!==f?(g=N(),null!==g?(Qd=a,c=Xc(),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,123===b.charCodeAt(Pd)?(c=nb,Pd++):(c=null,0===Vd&&d(ob)),null!==c?(e=N(),null!==e?(f=C(),null!==f?(125===b.charCodeAt(Pd)?(g=pb,Pd++):(g=null,0===Vd&&d(qb)),null!==g?(h=N(),null!==h?(Qd=a,c=Yc(f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)),a}function C(){var a,c,e,f,g,h,i;if(a=Pd,null!==(c=D())){for(e=[],f=Pd,44===b.charCodeAt(Pd)?(g=aa,Pd++):(g=null,0===Vd&&d(ba)),null!==g?(h=N(),null!==h?(i=D(),null!==i?(g=[g,h,i],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==f;)e.push(f),f=Pd,44===b.charCodeAt(Pd)?(g=aa,Pd++):(g=null,0===Vd&&d(ba)),null!==g?(h=N(),null!==h?(i=D(),null!==i?(g=[g,h,i],f=g):(Pd=f,f=_)):(Pd=f,f=_)):(Pd=f,f=_);null!==e?(Qd=a,c=Zc(c,e),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function D(){var a,c,f,g,h;return a=Pd,c=Pd,f=u(),null!==f&&(f=b.substring(c,Pd)),c=f,null!==c?(58===b.charCodeAt(Pd)?(f=ma,Pd++):(f=null,0===Vd&&d(na)),null!==f?(g=N(),null!==g?(h=e(),null!==h?(Qd=a,c=$c(c,h),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),a}function E(){var a,c,e;return Vd++,a=Pd,c=Pd,e=F(),null!==e&&(e=b.substring(c,Pd)),c=e,null!==c&&(Qd=a,c=ad(c)),null===c?(Pd=a,a=c):a=c,Vd--,null===a&&(c=null,0===Vd&&d(_c)),a}function F(){var a,b,c,d;return a=Pd,b=G(),null!==b?(c=H(),null!==c?(d=I(),null!==d?(b=[b,c,d],a=b):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,b=G(),null!==b?(c=H(),null!==c?(b=[b,c],a=b):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,b=G(),null!==b?(c=I(),null!==c?(b=[b,c],a=b):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=G()))),a}function G(){var a,c,e,f;return a=Pd,c=M(),null!==c?(e=J(),null!==e?(c=[c,e],a=c):(Pd=a,a=_)):(Pd=a,a=_),null===a&&null===(a=L())&&(a=Pd,45===b.charCodeAt(Pd)?(c=Ca,Pd++):(c=null,0===Vd&&d(Da)),null!==c?(e=M(),null!==e?(f=J(),null!==f?(c=[c,e,f],a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,45===b.charCodeAt(Pd)?(c=Ca,Pd++):(c=null,0===Vd&&d(Da)),null!==c?(e=L(),null!==e?(c=[c,e],a=c):(Pd=a,a=_)):(Pd=a,a=_))),a}function H(){var a,c,e;return a=Pd,46===b.charCodeAt(Pd)?(c=fb,Pd++):(c=null,0===Vd&&d(gb)),null!==c?(e=J(),null!==e?(c=[c,e],a=c):(Pd=a,a=_)):(Pd=a,a=_),a}function I(){var a,b,c;return a=Pd,b=K(),null!==b?(c=J(),null!==c?(b=[b,c],a=b):(Pd=a,a=_)):(Pd=a,a=_),a}function J(){var a,b;if(a=[],null!==(b=L()))for(;null!==b;)a.push(b),b=L();else a=_;return a}function K(){var a,c,e;return a=Pd,bd.test(b.charAt(Pd))?(c=b.charAt(Pd),Pd++):(c=null,0===Vd&&d(cd)),null!==c?(dd.test(b.charAt(Pd))?(e=b.charAt(Pd),Pd++):(e=null,0===Vd&&d(ed)),null===e&&(e=ja),null!==e?(c=[c,e],a=c):(Pd=a,a=_)):(Pd=a,a=_),a}function L(){var a;return fd.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(gd)),a}function M(){var a;return hd.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(id)),a}function N(){var a,b;for(a=[],b=O(),null===b&&(b=P());null!==b;)a.push(b),null===(b=O())&&(b=P());return a}function O(){var a;return Vd++,kd.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(ld)),null===a&&(md.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(nd))),Vd--,null===a&&(null,0===Vd&&d(jd)),a}function P(){var a;return Vd++,pd.test(b.charAt(Pd))?(a=b.charAt(Pd),Pd++):(a=null,0===Vd&&d(qd)),Vd--,null===a&&(null,0===Vd&&d(od)),a}function Q(){var a,b,c,d;if(a=Pd,null!==(b=N())){for(c=[],d=R();null!==d;)c.push(d),d=R();null!==c?(d=N(),null!==d?(Qd=a,b=rd(c),null===b?(Pd=a,a=b):a=b):(Pd=a,a=_)):(Pd=a,a=_)}else Pd=a,a=_;return a}function R(){var a,c,e,f,g,h,i,j,k,l;return a=Pd,64===b.charCodeAt(Pd)?(c=Ib,Pd++):(c=null,0===Vd&&d(Jb)),null!==c?(e=Pd,f=T(),null!==f&&(f=b.substring(e,Pd)),e=f,null!==e?(f=N(),null!==f?(g=S(),null===g&&(g=ja),null!==g?(123===b.charCodeAt(Pd)?(h=nb,Pd++):(h=null,0===Vd&&d(ob)),null!==h?(i=N(),null!==i?(j=U(),null!==j?(125===b.charCodeAt(Pd)?(k=pb,Pd++):(k=null,0===Vd&&d(qb)),null!==k?(l=N(),null!==l?(Qd=a,c=sd(e,g,j),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),a}function S(){var a,c,f,g,h,i,j,k;return a=Pd,60===b.charCodeAt(Pd)?(c=Aa,Pd++):(c=null,0===Vd&&d(Ba)),null===c&&(58===b.charCodeAt(Pd)?(c=ma,Pd++):(c=null,0===Vd&&d(na))),null!==c?(f=N(),null!==f?(g=v(),null===g&&(g=ja),null!==g?(h=N(),null!==h?(i=Pd,j=Pd,Vd++,123===b.charCodeAt(Pd)?(k=nb,Pd++):(k=null,0===Vd&&d(ob)),Vd--,null===k?j=ja:(Pd=j,j=_),null!==j?(k=e(),null!==k?(j=[j,k],i=j):(Pd=i,i=_)):(Pd=i,i=_),null===i&&(i=ja),null!==i?(j=N(),null!==j?(Qd=a,c=td(c,g,i),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,c=N(),null!==c&&(Qd=a,c=ud()),null===c?(Pd=a,a=c):a=c),a}function T(){var a,c,e,f,g,h,i;if(a=Pd,c=[],vd.test(b.charAt(Pd))?(e=b.charAt(Pd),Pd++):(e=null,0===Vd&&d(wd)),null!==e)for(;null!==e;)c.push(e),vd.test(b.charAt(Pd))?(e=b.charAt(Pd),Pd++):(e=null,0===Vd&&d(wd));else c=_;if(null!==c){if(e=[],f=Pd,58===b.charCodeAt(Pd)?(g=ma,Pd++):(g=null,0===Vd&&d(na)),null!==g){if(h=[],vd.test(b.charAt(Pd))?(i=b.charAt(Pd),Pd++):(i=null,0===Vd&&d(wd)),null!==i)for(;null!==i;)h.push(i),vd.test(b.charAt(Pd))?(i=b.charAt(Pd),Pd++):(i=null,0===Vd&&d(wd));else h=_;null!==h?(g=[g,h],f=g):(Pd=f,f=_)}else Pd=f,f=_;for(;null!==f;)if(e.push(f),f=Pd,58===b.charCodeAt(Pd)?(g=ma,Pd++):(g=null,0===Vd&&d(na)),null!==g){if(h=[],vd.test(b.charAt(Pd))?(i=b.charAt(Pd),Pd++):(i=null,0===Vd&&d(wd)),null!==i)for(;null!==i;)h.push(i),vd.test(b.charAt(Pd))?(i=b.charAt(Pd),Pd++):(i=null,0===Vd&&d(wd));else h=_;null!==h?(g=[g,h],f=g):(Pd=f,f=_)}else Pd=f,f=_;null!==e?(c=[c,e],a=c):(Pd=a,a=_)}else Pd=a,a=_;return a}function U(){var a,c,e,f,g,h,i,j,k;if(a=Pd,null!==(c=V()))if(null!==(e=N())){for(f=[],g=Pd,59===b.charCodeAt(Pd)?(h=xd,Pd++):(h=null,0===Vd&&d(yd)),null!==h?(i=N(),null!==i?(j=V(),null!==j?(k=N(),null!==k?(h=[h,i,j,k],g=h):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_);null!==g;)f.push(g),g=Pd,59===b.charCodeAt(Pd)?(h=xd,Pd++):(h=null,0===Vd&&d(yd)),null!==h?(i=N(),null!==i?(j=V(),null!==j?(k=N(),null!==k?(h=[h,i,j,k],g=h):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_)):(Pd=g,g=_);null!==f?(59===b.charCodeAt(Pd)?(g=xd,Pd++):(g=null,0===Vd&&d(yd)),null===g&&(g=ja),null!==g?(h=N(),null!==h?(Qd=a,c=ca(c,f),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)}else Pd=a,a=_;else Pd=a,a=_;return null===a&&(a=Pd,c=V(),null!==c?(e=N(),null!==e?(59===b.charCodeAt(Pd)?(f=xd,Pd++):(f=null,0===Vd&&d(yd)),null===f&&(f=ja),null!==f?(g=N(),null!==g?(Qd=a,c=zd(c),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a&&(a=Pd,c=N(),null!==c&&(Qd=a,c=ha()),null===c?(Pd=a,a=c):a=c)),a}function V(){var a,c,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;if(a=Pd,b.substr(Pd,2)===Ad?(c=Ad,Pd+=2):(c=null,0===Vd&&d(Bd)),null===c&&(b.substr(Pd,6)===Cd?(c=Cd,Pd+=6):(c=null,0===Vd&&d(Dd))),null!==c?(32===b.charCodeAt(Pd)?(f=Ed,Pd++):(f=null,0===Vd&&d(Fd)),null!==f?(g=N(),null!==g?(h=Pd,i=u(),null!==i&&(i=b.substring(h,Pd)),h=i,null!==h?(i=N(),null!==i?(b.substr(Pd,2)===Gd?(j=Gd,Pd+=2):(j=null,0===Vd&&d(Hd)),null!==j?(k=N(),null!==k?(l=e(),null!==l?(m=N(),null!==m?(Qd=a,c=Id(c,h,l),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_),null===a){if(a=Pd,null!==(c=e()))if(null!==(f=N()))if(58===b.charCodeAt(Pd)?(g=ma,Pd++):(g=null,0===Vd&&d(na)),null===g&&(b.substr(Pd,3)===Jd?(g=Jd,Pd+=3):(g=null,0===Vd&&d(Kd)),null===g&&(b.substr(Pd,2)===Ld?(g=Ld,Pd+=2):(g=null,0===Vd&&d(Md)))),null!==g)if(null!==(h=N()))if(null!==(i=e()))if(null!==(j=N())){for(k=[],l=Pd,44===b.charCodeAt(Pd)?(m=aa,Pd++):(m=null,0===Vd&&d(ba)),null!==m?(n=N(),null!==n?(o=Pd,p=u(),null!==p&&(p=b.substring(o,Pd)),o=p,null!==o?(p=N(),null!==p?(58===b.charCodeAt(Pd)?(q=ma,Pd++):(q=null,0===Vd&&d(na)),null!==q?(r=N(),null!==r?(s=e(),null!==s?(t=N(),null!==t?(m=[m,n,o,p,q,r,s,t],l=m):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_);null!==l;)k.push(l),l=Pd,44===b.charCodeAt(Pd)?(m=aa,Pd++):(m=null,0===Vd&&d(ba)),null!==m?(n=N(),null!==n?(o=Pd,p=u(),null!==p&&(p=b.substring(o,Pd)),o=p,null!==o?(p=N(),null!==p?(58===b.charCodeAt(Pd)?(q=ma,Pd++):(q=null,0===Vd&&d(na)),null!==q?(r=N(),null!==r?(s=e(),null!==s?(t=N(),null!==t?(m=[m,n,o,p,q,r,s,t],l=m):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_)):(Pd=l,l=_);null!==k?(Qd=a,c=Nd(c,g,i,k),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)}else Pd=a,a=_;else Pd=a,a=_;else Pd=a,a=_;else Pd=a,a=_;else Pd=a,a=_;else Pd=a,a=_;null===a&&(a=Pd,c=Pd,f=u(),null!==f&&(f=b.substring(c,Pd)),c=f,null!==c?(f=N(),null!==f?(g=e(),null!==g?(h=N(),null!==h?(Qd=a,c=Od(c,g),null===c?(Pd=a,a=c):a=c):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_)):(Pd=a,a=_))}return a}var W,X=arguments.length>1?arguments[1]:{},Y={expression:e,sheet:Q},Z=e,$="expression",_=null,aa=",",ba='","',ca=function(a,b){for(var c=[a],d=0;d<b.length;d++)c.push(b[d][2]);return c},da="(",ea='"("',fa=")",ga='")"',ha=function(){return[]},ia=function(a){return a},ja="",ka="?",la='"?"',ma=":",na='":"',oa=function(a,b){if(b){return{type:"if",args:[a,b[2],b[6]]}}return a},pa="||",qa='"||"',ra=function(a,b){for(var c=0;c<b.length;c++)a={type:Wd[b[c][1]],args:[a,b[c][3]]};return a},sa="&&",ta='"&&"',ua="<=>",va='"<=>"',wa="<=",xa='"<="',ya=">=",za='">="',Aa="<",Ba='"<"',Ca="-",Da='"-"',Ea=">",Fa='">"',Ga="==",Ha='"=="',Ia="!=",Ja='"!="',Ka=function(a,b){if(b){var c=b[1],d=b[3];return"!="===c?{type:"not",args:[{type:"equals",args:[a,d]}]}:{type:Wd[c],args:[a,d]}}return a},La="+",Ma='"+"',Na="*",Oa='"*"',Pa="/",Qa='"/"',Ra="%",Sa='"%"',Ta="rem",Ua='"rem"',Va="**",Wa='"**"',Xa="//",Ya='"//"',Za="%%",$a='"%%"',_a="??",ab='"??"',bb="!",cb='"!"',db=function(a,b){return{type:Xd[a],args:[b]}},eb=function(a,b){for(var c=0;c<b.length;c++)a=b[c](a);return a},fb=".",gb='"."',hb=function(a){return a},ib="[",jb='"["',kb="]",lb='"]"',mb=function(a){return function(b){return{type:"property",args:[b,a]}}},nb="{",ob='"{"',pb="}",qb='"}"',rb=function(a,b){return Yd[a]?function(c){return{type:Yd[a],args:[c,b]}}:"value"===b.type?function(b){return{type:a,args:[b]}}:function(c){return{type:a,args:[{type:"mapBlock",args:[c,b]}]}}},sb=function(a,b){return function(c){return{type:a,args:[c].concat(b)}}},tb=function(a){return function(b){return{type:"property",args:[b,{type:"literal",value:+a.join("")}]}}},ub=function(a){return function(b){return{type:"property",args:[b,{type:"literal",value:a}]}}},vb=function(a){return function(b){return{type:"with",args:[b,a]}}},wb="this",xb='"this"',yb=function(){return{type:"value"}},zb="true",Ab='"true"',Bb=function(){return{type:"literal",value:!0}},Cb="false",Db='"false"',Eb=function(){return{type:"literal",value:!1}},Fb="null",Gb='"null"',Hb=function(){return{type:"literal",value:null}},Ib="@",Jb='"@"',Kb=function(a){return{type:"component",label:a}},Lb="$",Mb='"$"',Nb=function(a){return{type:"property",args:[{type:"parameters"},{type:"literal",value:a}]}},Ob=function(){return{type:"parameters"}},Pb="#",Qb='"#"',Rb=function(a){return{type:"element",id:a}},Sb="&",Tb='"&"',Ub=function(a,b){return{type:a,args:b,inline:!0}},Vb="^",Wb='"^"',Xb=function(a){return{type:"parent",args:[a]}},Yb=function(a){return a},Zb=function(a){return a({type:"value"})},$b=function(){return{type:"value"}},_b="word",ac=/^[a-zA-Z_0-9\-]/,bc="[a-zA-Z_0-9\\-]",cc="string",dc="'",ec='"\'"',fc=function(a){return{type:"literal",value:a.join("")}},gc='"',hc='"\\""',ic=/^[^'\\\0-\x1F]/,jc="[^'\\\\\\0-\\x1F]",kc="\\'",lc='"\\\\\'"',mc=function(){return"'"},nc=/^[^"\\\0-\x1F]/,oc='[^"\\\\\\0-\\x1F]',pc='\\"',qc='"\\\\\\""',rc=function(){return'"'},sc="\\\\",tc='"\\\\\\\\"',uc=function(){return"\\"},vc="\\/",wc='"\\\\/"',xc=function(){return"/"},yc="\\b",zc='"\\\\b"',Ac=function(){return"\b"},Bc="\\f",Cc='"\\\\f"',Dc=function(){return"\f"},Ec="\\n",Fc='"\\\\n"',Gc=function(){return"\n"},Hc="\\r",Ic='"\\\\r"',Jc=function(){return"\r"},Kc="\\t",Lc='"\\\\t"',Mc=function(){return"\t"},Nc="\\0",Oc='"\\\\0"',Pc=function(){return"\0"},Qc="\\u",Rc='"\\\\u"',Sc=function(a){return String.fromCharCode(parseInt(a,16))},Tc=/^[0-9a-fA-F]/,Uc="[0-9a-fA-F]",Vc=function(){return{type:"tuple",args:[]}},Wc=function(a){return{type:"tuple",args:a}},Xc=function(){return{type:"record",args:[]}},Yc=function(a){return{type:"record",args:a}},Zc=function(a,b){var c={};c[a[0]]=a[1];for(var d=0;d<b.length;d++)c[b[d][2][0]]=b[d][2][1];return c},$c=function(a,b){return[a,b]},_c="number",ad=function(a){return{type:"literal",value:+a}},bd=/^[eE]/,cd="[eE]",dd=/^[+\-]/,ed="[+\\-]",fd=/^[0-9]/,gd="[0-9]",hd=/^[1-9]/,id="[1-9]",jd="whitespace",kd=/^[\t\x0B\f \xA0\uFEFF]/,ld="[\\t\\x0B\\f \\xA0\\uFEFF]",md=/^[ \xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000]/,nd="[ \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000]",od="line terminator",pd=/^[\n\r\u2028\u2029]/,qd="[\\n\\r\\u2028\\u2029]",rd=function(a){return{type:"sheet",blocks:a}},sd=function(a,b,c){return{type:"block",connection:b.connection,module:b.module,exports:b.exports,label:a,statements:c}},td=function(a,b,c){return{connection:{"<":"prototype",":":"object"}[a],module:b&&b.value,exports:""!==c?c[1]:void 0}},ud=function(){return{}},vd=/^[a-zA-Z_0-9]/,wd="[a-zA-Z_0-9]",xd=";",yd='";"',zd=function(a){return[a]},Ad="on",Bd='"on"',Cd="before",Dd='"before"',Ed=" ",Fd='" "',Gd="->",Hd='"->"',Id=function(a,b,c){return{type:"event",when:a,event:b,listener:c}},Jd="<->",Kd='"<->"',Ld="<-",Md='"<-"',Nd=function(a,b,c,d){var e={type:Zd[b],args:[a,c]};if(d.length){for(var f={},g=0;g<d.length;g++)f[d[g][2]]=d[g][6];e.descriptor=f}return e},Od=function(a,b){return{type:"unit",name:a,value:b}},Pd=0,Qd=0,Rd=0,Sd={line:1,column:1,seenCR:!1},Td=0,Ud=[],Vd=0;if("startRule"in X){if(!(X.startRule in Y))throw new Error("Can't start parsing from rule \""+X.startRule+'".');Z=Y[X.startRule]}var Wd={"**":"pow","//":"root","%%":"log","*":"mul","/":"div","%":"mod",rem:"rem","+":"add","-":"sub","<":"lt",">":"gt","<=":"le",">=":"ge","==":"equals","<=>":"compare","??":"default","&&":"and","||":"or","<-":"bind","<->":"bind2",":":"assign"},Xd={"+":"toNumber","-":"neg","!":"not","^":"parent"},Yd={map:"mapBlock",filter:"filterBlock",some:"someBlock",every:"everyBlock",sorted:"sortedBlock",sortedSet:"sortedSetBlock",group:"groupBlock",groupMap:"groupMapBlock",min:"minBlock",max:"maxBlock"},Zd={":":"assign","<-":"bind","<->":"bind2"};if(null!==(W=Z())&&Pd===b.length)return W;throw function(a){var b=0;for(a.sort();b<a.length;)a[b-1]===a[b]?a.splice(b,1):b++}(Ud),Qd=Math.max(Pd,Td),new a(Ud,Qd<b.length?b.charAt(Qd):null,Qd,c(Qd).line,c(Qd).column)}return function(a,b){function c(){this.constructor=a}c.prototype=b.prototype,a.prototype=new c}(a,Error),{SyntaxError:a,parse:b}}()},{}],37:[function(a,b,c){var d=a("collections/set"),e=a("collections/dict"),f=c.precedence=e();(c.precedenceLevels=[["tuple","record"],["literal","value","parameters","property","element","component","mapBlock","filterBlock","sortedBlock","groupBlock","groupMapBlock","with"],["not","neg","number","parent"],["scope"],["default"],["pow","root","log"],["mul","div","mod","rem"],["add","sub"],["equals","lt","gt","le","ge","compare"],["and"],["or"],["if"]]).forEach(function(a){var b=d(f.keys());a.forEach(function(a){f.set(a,b)})});var g=c.operatorTokens=e({"**":"pow","//":"root","%%":"log","*":"mul","/":"div","%":"mod",rem:"rem","+":"add","-":"sub","<":"lt",">":"gt","<=":"le",">=":"ge","==":"equals","<=>":"compare","!=":"notEquals","??":"default","&&":"and","||":"or","?":"then",":":"else"});c.operatorTypes=e(g.map(function(a,b){return[a,b]}))},{"collections/dict":39,"collections/set":53}],38:[function(a,b,c){"use strict";function d(a,b){for(var c,d=(b.length+1)*(a.length+1),e=Array(d),f=Array(b.length+1),g=Array(b.length+1),h=0;h<a.length+1;h++){for(var i=0;i<b.length+1;i++){var j,k;if(0===h&&0===i)j=" ",k=0;else if(0===h)j="insert",k=i;else if(0===i)j="delete",k=h;else if(a[h-1]===b[i-1])j="retain",k=g[i-1];else{var l=f[i-1],m=g[i];m<l?(j="delete",k=m+1):(j="insert",k=l+1)}e[h+i*(a.length+1)]=j,f[i]=k}c=f,f=g,g=c}return{edges:e,cost:g[b.length],source:b,target:a}}function e(a){for(var b,c,d=[],e=a.edges,f=b=a.target.length,g=a.source.length;b||g;){var h=e[b+g*(f+1)];if("delete"===h){if(c&&"delete"===c[0])c[1]++;else{var i=["delete",1];c=i,d.push(i)}b--}else if("insert"===h){if(c&&"insert"===c[0])c[1]++;else{var i=["insert",1];c=i,d.push(i)}g--}else if("retain"===h){var i=["retain",1];c&&"retain"===c[0]?c[1]++:(c=i,d.push(i)),b--,g--}}return d.reverse(),d}function f(a,b){return e(d(a,b))}function g(a,b){for(var c=f(a,b),d=[],e=0,g=0,h=0;h<c.length;){var i=c[h++];if("insert"===i[0])d.push([g,0,b.slice(g,g+i[1])]),g+=i[1];else if("delete"===i[0])if(h<c.length&&"insert"===c[h][0]){var j=c[h++];d.push([g,i[1],b.slice(g,g+j[1])]),e+=i[1],g+=j[1]}else d.push([g,i[1]]),e+=i[1];else"retain"==i[0]&&(e+=i[1],g+=i[1])}return d}function h(a,b){for(var c=0;c<b.length;c++)a.swap.apply(a,b[c])}function i(a,b){h(a,g(a,b))}a("collections/shim"),c.graphOt=d,c.traceOt=e,c.ot=f,c.diff=g,c.apply=h,c.merge=i},{"collections/shim":58}],39:[function(a,b,c){"use strict";function d(a,b){if(!(this instanceof d))return new d(a,b);b=b||Function.noop,this.getDefault=b,this.store={},this.length=0,this.addEach(a)}function e(a){return"~"+a}function f(a){return a.slice(1)}var g=(a("./shim"),a("./generic-collection")),h=a("./generic-map"),i=a("./listen/property-changes");b.exports=d,d.Dict=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.mangle,this.getDefault)},d.prototype.assertString=function(a){if("string"!=typeof a)throw new TypeError("key must be a string but Got "+a)},d.prototype.get=function(a,b){this.assertString(a);var c=e(a);return c in this.store?this.store[c]:arguments.length>1?b:this.getDefault(a)},d.prototype.set=function(a,b){this.assertString(a);var c=e(a);return c in this.store?(this.dispatchesBeforeMapChanges&&this.dispatchBeforeMapChange(a,this.store[c]),this.store[c]=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b),!1):(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,void 0),this.length++,this.store[c]=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b),!0)},d.prototype.has=function(a){return this.assertString(a),e(a)in this.store},d.prototype.delete=function(a){this.assertString(a);var b=e(a);return b in this.store&&(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,this.store[b]),delete this.store[e(a)],this.length--,this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0),!0)},d.prototype.clear=function(){var a,b;for(b in this.store)a=f(b),this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,this.store[b]),delete this.store[b],this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0);this.length=0},d.prototype.reduce=function(a,b,c){for(var d in this.store)b=a.call(c,b,this.store[d],f(d),this);return b},d.prototype.reduceRight=function(a,b,c){var d=this,e=this.store;return Object.keys(this.store).reduceRight(function(b,g){return a.call(c,b,e[g],f(g),d)},b)},d.prototype.one=function(){var a;for(a in this.store)return this.store[a]}},{"./generic-collection":41,"./generic-map":42,"./listen/property-changes":49,"./shim":58}],40:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);b=b||Object.equals,c=c||Object.hash,e=e||Function.noop,this.contentEquals=b,this.contentHash=c,this.getDefault=e,this.buckets=new this.Buckets(null,this.Bucket),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./dict")),f=a("./list"),g=a("./generic-collection"),h=a("./generic-set"),i=a("./tree-log"),j=a("./listen/property-changes");Object.prototype.hasOwnProperty;b.exports=d,d.FastSet=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.Buckets=e,d.prototype.Bucket=f,d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentHash,this.getDefault)},d.prototype.has=function(a){var b=this.contentHash(a);return this.buckets.get(b).has(a)},d.prototype.get=function(a){var b=this.contentHash(a),c=this.buckets;return c.has(b)?c.get(b).get(a):this.getDefault(a)},d.prototype.delete=function(a){var b=this.contentHash(a),c=this.buckets;if(c.has(b)){var d=c.get(b);if(d.delete(a))return this.length--,0===d.length&&c.delete(b),!0}return!1},d.prototype.clear=function(){this.buckets.clear(),this.length=0},d.prototype.add=function(a){var b=this.contentHash(a),c=this.buckets;return c.has(b)||c.set(b,new this.Bucket(null,this.contentEquals)),!c.get(b).has(a)&&(c.get(b).add(a),this.length++,!0)},d.prototype.reduce=function(a,b){var c=arguments[2],d=0;return this.buckets.reduce(function(b,e){return e.reduce(function(b,e){return a.call(c,b,e,d++,this)},b,this)},b,this)},d.prototype.one=function(){if(this.length>0)return this.buckets.one().one()},d.prototype.iterate=function(){return this.buckets.values().flatten().iterate()},d.prototype.log=function(a,b,c,d){a=a||i.unicodeSharp,b=b||this.logNode,c||(c=console.log,d=console),c=c.bind(d);var e=this.buckets,f=e.keys();f.forEach(function(g,h){var i,j;h===f.length-1?(i=a.fromAbove,j=" "):0===h?(i=a.branchDown,j=a.strafe):(i=a.fromBoth,j=a.strafe);var k=e.get(g);c.call(d,i+a.through+a.branchDown+" "+g),k.forEach(function(e,f){var g,h;f===k.head.prev?(g=a.fromAbove,h=" "):(g=a.fromBoth,h=a.strafe);var i;b(f,function(b){i?c.call(d,j+" "+h+"  "+b):(c.call(d,j+" "+g+a.through+a.through+b),i=!0)},function(b){c.call(d,j+" "+a.strafe+"  "+b)})})})},d.prototype.logNode=function(a,b){var c=a.value;Object(c)===c?JSON.stringify(c,null,4).split("\n").forEach(function(a){b(" "+a)}):b(" "+c)}},{"./dict":39,"./generic-collection":41,"./generic-set":44,"./list":46,"./listen/property-changes":49,"./shim":58,"./tree-log":61}],41:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. GenericCollection is a mixin.")}b.exports=d,d.prototype.addEach=function(a){if(a&&Object(a)===a)if("function"==typeof a.forEach)a.forEach(this.add,this);else if("number"==typeof a.length)for(var b=0;b<a.length;b++)this.add(a[b],b);else Object.keys(a).forEach(function(b){this.add(a[b],b)},this);return this},d.prototype.deleteEach=function(a,b){return a.forEach(function(a){this.delete(a,b)},this),this},d.prototype.forEach=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){a.call(b,d,e,f,g)},void 0)},d.prototype.map=function(a){var b=arguments[1],c=[];return this.reduce(function(d,e,f,g,h){c.push(a.call(b,e,f,g,h))},void 0),c},d.prototype.enumerate=function(a){null==a&&(a=0);var b=[];return this.reduce(function(c,d){b.push([a++,d])},void 0),b},d.prototype.group=function(a,b,c){c=c||Object.equals;var d=[],e=[];return this.forEach(function(f,g,h){var i,g=a.call(b,f,g,h),j=e.indexOf(g,c);j===-1?(i=[],d.push([g,i]),e.push(g)):i=d[j][1],i.push(f)}),d},d.prototype.toArray=function(){return this.map(Function.identity)},d.prototype.toObject=function(){var a={};return this.reduce(function(b,c,d){a[d]=c},void 0),a},d.prototype.filter=function(a){var b=arguments[1],c=this.constructClone();return this.reduce(function(d,e,f,g,h){a.call(b,e,f,g,h)&&c.add(e)},void 0),c},d.prototype.every=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){return c&&a.call(b,d,e,f,g)},!0)},d.prototype.some=function(a){var b=arguments[1];return this.reduce(function(c,d,e,f,g){return c||a.call(b,d,e,f,g)},!1)},d.prototype.all=function(){return this.every(Boolean)},d.prototype.any=function(){return this.some(Boolean)},d.prototype.min=function(a){a=a||this.contentCompare||Object.compare;var b=!0;return this.reduce(function(c,d){return b?(b=!1,d):a(d,c)<0?d:c},void 0)},d.prototype.max=function(a){a=a||this.contentCompare||Object.compare;var b=!0;return this.reduce(function(c,d){return b?(b=!1,d):a(d,c)>0?d:c},void 0)},d.prototype.sum=function(a){return a=void 0===a?0:a,this.reduce(function(a,b){return a+b},a)},d.prototype.average=function(a){var b=void 0===a?0:a,c=void 0===a?0:a;return this.reduce(function(a,d){b+=d,c+=1},void 0),b/c},d.prototype.concat=function(){for(var a=this.constructClone(this),b=0;b<arguments.length;b++)a.addEach(arguments[b]);return a},d.prototype.flatten=function(){var a=this;return this.reduce(function(b,c){return c.forEach(function(a){this.push(a)},b,a),b},[])},d.prototype.zip=function(){var a=Array.prototype.slice.call(arguments);return a.unshift(this),Array.unzip(a)},d.prototype.join=function(a){return this.reduce(function(b,c){return b+a+c})},d.prototype.sorted=function(a,b,c){return a=a||this.contentCompare||Object.compare,a.by?(b=a.by,a=a.compare||this.contentCompare||Object.compare):b=b||Function.identity,void 0===c&&(c=1),this.map(function(a){return{by:b(a),value:a}}).sort(function(b,d){return a(b.by,d.by)*c}).map(function(a){return a.value})},d.prototype.reversed=function(){return this.constructClone(this).reverse()},d.prototype.clone=function(a,b){if(void 0===a)a=1/0;else if(0===a)return this;var c=this.constructClone();return this.forEach(function(d,e){c.add(Object.clone(d,a-1,b),e)},this),c},d.prototype.only=function(){if(1===this.length)return this.one()},d.prototype.iterator=function(){return this.iterate.apply(this,arguments)},a("./shim-array")},{"./shim-array":54}],42:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. GenericMap is a mixin.")}function e(a,b){this.key=a,this.value=b}var f=a("./shim-object"),g=a("./listen/map-changes"),h=a("./listen/property-changes");b.exports=d,f.addEach(d.prototype,g.prototype),f.addEach(d.prototype,h.prototype),d.prototype.isMap=!0,d.prototype.addEach=function(a){return a&&f(a)===a&&("function"==typeof a.forEach?a.isMap===!0?a.forEach(function(a,b){this.set(b,a)},this):a.forEach(function(a){this.set(a[0],a[1])},this):f.keys(a).forEach(function(b){this.set(b,a[b])},this)),this},d.prototype.get=function(a,b){var c=this.store.get(new this.Item(a));return c?c.value:arguments.length>1?b:this.getDefault(a)},d.prototype.set=function(a,b){var c=new this.Item(a,b),d=this.store.get(c),e=!1;return d?(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,d.value),d.value=b,this.dispatchesMapChanges&&this.dispatchMapChange(a,b)):(this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,void 0),this.store.add(c)&&(this.length++,e=!0),this.dispatchesMapChanges&&this.dispatchMapChange(a,b)),e},d.prototype.add=function(a,b){return this.set(b,a)},d.prototype.has=function(a){return this.store.has(new this.Item(a))},d.prototype.delete=function(a){var b=new this.Item(a);if(this.store.has(b)){var c=this.store.get(b).value;return this.dispatchesMapChanges&&this.dispatchBeforeMapChange(a,c),this.store.delete(b),this.length--,this.dispatchesMapChanges&&this.dispatchMapChange(a,void 0),!0}return!1},d.prototype.clear=function(){var a;this.dispatchesMapChanges&&(this.forEach(function(a,b){this.dispatchBeforeMapChange(b,a)},this),a=this.keys()),this.store.clear(),this.length=0,this.dispatchesMapChanges&&a.forEach(function(a){this.dispatchMapChange(a)},this)},d.prototype.reduce=function(a,b,c){return this.store.reduce(function(b,d){return a.call(c,b,d.value,d.key,this)},b,this)},d.prototype.reduceRight=function(a,b,c){return this.store.reduceRight(function(b,d){return a.call(c,b,d.value,d.key,this)},b,this)},d.prototype.keys=function(){return this.map(function(a,b){return b})},d.prototype.values=function(){return this.map(Function.identity)},d.prototype.entries=function(){return this.map(function(a,b){return[b,a]})},d.prototype.items=function(){return this.entries()},d.prototype.equals=function(a,b){return b=b||f.equals,this===a||(f.can(a,"every")?a.length===this.length&&a.every(function(a,c){
+return b(this.get(c),a)},this):f.keys(a).length===this.length&&f.keys(a).every(function(c){return b(this.get(c),a[c])},this))},d.prototype.Item=e,e.prototype.equals=function(a){return f.equals(this.key,a.key)&&f.equals(this.value,a.value)},e.prototype.compare=function(a){return f.compare(this.key,a.key)}},{"./listen/map-changes":48,"./listen/property-changes":49,"./shim-object":56}],43:[function(a,b,c){function d(){throw new Error("Can't construct. GenericOrder is a mixin.")}var e=a("./shim-object");b.exports=d,d.prototype.equals=function(a,b){if(b=b||this.contentEquals||e.equals,this===a)return!0;if(!a)return!1;return this.length===a.length&&this.zip(a).every(function(a){return b(a[0],a[1])})},d.prototype.compare=function(a,b){if(b=b||this.contentCompare||e.compare,this===a)return 0;if(!a)return 1;var c=Math.min(this.length,a.length),d=this.zip(a).reduce(function(a,d,e){return 0===a?e>=c?a:b(d[0],d[1]):a},0);return 0===d?this.length-a.length:d}},{"./shim-object":56}],44:[function(a,b,c){function d(){throw new Error("Can't construct. GenericSet is a mixin.")}b.exports=d,d.prototype.union=function(a){var b=this.constructClone(this);return b.addEach(a),b},d.prototype.intersection=function(a){return this.constructClone(this.filter(function(b){return a.has(b)}))},d.prototype.difference=function(a){var b=this.constructClone(this);return b.deleteEach(a),b},d.prototype.symmetricDifference=function(a){var b=this.union(a),c=this.intersection(a);return b.difference(c)},d.prototype.equals=function(a,b){var c=this;return Object.can(a,"reduce")&&this.length===a.length&&a.reduce(function(a,d){return a&&c.has(d,b)},!0)},d.prototype.contains=function(a){return this.has(a)},d.prototype.remove=function(a){return this.delete(a)},d.prototype.toggle=function(a){this.has(a)?this.delete(a):this.add(a)}},{}],45:[function(a,b,c){function d(a,b,c){if(!(this instanceof d))return new d(a,b,c);this.contentEquals=b||Object.equals,this.contentCompare=c||Object.compare,this.content=[],this.length=0,this.addEach(a)}var e=(a("./listen/array-changes"),a("./shim"),a("./generic-collection")),f=a("./listen/map-changes"),g=a("./listen/range-changes"),h=a("./listen/property-changes");b.exports=d,d.Heap=d,Object.addEach(d.prototype,e.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,f.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentCompare)},d.prototype.push=function(a){this.content.push(a),this.float(this.content.length-1),this.length++},d.prototype.pop=function(){var a=this.content[0],b=this.content.pop();return this.content.length>0&&(this.content.set(0,b),this.sink(0)),this.length--,a},d.prototype.add=function(a){this.push(a)},d.prototype.indexOf=function(a){for(var b=0;b<this.length;b++)if(this.contentEquals(this.content[b],a))return b;return-1},d.prototype.delete=function(a){var b=this.indexOf(a);if(b===-1)return!1;var c=this.content.pop();if(b===this.content.length)return!0;this.content.set(b,c);var d=this.contentCompare(c,a);return d>0?this.float(b):d<0&&this.sink(b),this.length--,!0},d.prototype.peek=function(){if(this.length)return this.content[0]},d.prototype.max=function(){return this.peek()},d.prototype.one=function(){return this.peek()},d.prototype.float=function(a){for(var b=this.content[a];a>0;){var c=Math.floor((a+1)/2)-1,d=this.content[c];if(!(this.contentCompare(d,b)<0))break;this.content.set(c,b),this.content.set(a,d),a=c}},d.prototype.sink=function(a){for(var b,c,d,e,f,g,h=this.content.length,i=this.content[a];;){if(e=2*(a+1),d=e-1,g=!1,d<h){var b=this.content[d],j=this.contentCompare(b,i);j>0&&(f=d,g=!0)}if(e<h){var c=this.content[e],j=this.contentCompare(c,g?b:i);j>0&&(f=e,g=!0)}if(!g)break;this.content.set(a,this.content[f]),this.content.set(f,i),a=f}},d.prototype.clear=function(){this.content.clear(),this.length=0},d.prototype.reduce=function(a,b){var c=arguments[2];return this.content.reduce(function(b,d,e){return a.call(c,b,d,e,this)},b,this)},d.prototype.reduceRight=function(a,b){var c=arguments[2];return this.content.reduceRight(function(b,d,e){return a.call(c,b,d,e,this)},b,this)},d.prototype.makeObservable=function(){this.content.addRangeChangeListener(this,"content"),this.content.addBeforeRangeChangeListener(this,"content"),this.content.addMapChangeListener(this,"content"),this.content.addBeforeMapChangeListener(this,"content")},d.prototype.handleContentRangeChange=function(a,b,c){this.dispatchRangeChange(a,b,c)},d.prototype.handleContentRangeWillChange=function(a,b,c){this.dispatchBeforeRangeChange(a,b,c)},d.prototype.handleContentMapChange=function(a,b){this.dispatchMapChange(b,a)},d.prototype.handleContentMapWillChange=function(a,b){this.dispatchBeforeMapChange(b,a)}},{"./generic-collection":41,"./listen/array-changes":47,"./listen/map-changes":48,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],46:[function(a,b,c){"use strict";function d(a,b,c){if(!(this instanceof d))return new d(a,b,c);var e=this.head=new this.Node;e.next=e,e.prev=e,this.contentEquals=b||Object.equals,this.getDefault=c||Function.noop,this.length=0,this.addEach(a)}function e(a){this.head=a,this.at=a.next}function f(a){this.value=a,this.prev=null,this.next=null}b.exports=d;var g=(a("./shim"),a("./generic-collection")),h=a("./generic-order"),i=a("./listen/property-changes"),j=a("./listen/range-changes");d.List=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.getDefault)},d.prototype.find=function(a,b){b=b||this.contentEquals;for(var c=this.head,d=c.next;d!==c;){if(b(d.value,a))return d;d=d.next}},d.prototype.findLast=function(a,b){b=b||this.contentEquals;for(var c=this.head,d=c.prev;d!==c;){if(b(d.value,a))return d;d=d.prev}},d.prototype.has=function(a,b){return!!this.find(a,b)},d.prototype.get=function(a,b){var c=this.find(a,b);return c?c.value:this.getDefault(a)},d.prototype.delete=function(a,b){var c=this.findLast(a,b);if(c){if(this.dispatchesRangeChanges){var d=[],e=[a];this.dispatchBeforeRangeChange(d,e,c.index)}return c.delete(),this.length--,this.dispatchesRangeChanges&&(this.updateIndexes(c.next,c.index),this.dispatchRangeChange(d,e,c.index)),!0}return!1},d.prototype.clear=function(){var a,b;this.dispatchesRangeChanges&&(b=this.toArray(),a=[],this.dispatchBeforeRangeChange(a,b,0)),this.head.next=this.head.prev=this.head,this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange(a,b,0)},d.prototype.add=function(a){var b=new this.Node(a);return this.dispatchesRangeChanges&&(b.index=this.length,this.dispatchBeforeRangeChange([a],[],b.index)),this.head.addBefore(b),this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],b.index),!0},d.prototype.push=function(){var a=this.head;if(this.dispatchesRangeChanges){var b=Array.prototype.slice.call(arguments),c=[],d=this.length;this.dispatchBeforeRangeChange(b,c,d);var e=this.head.prev}for(var f=0;f<arguments.length;f++){var g=arguments[f],h=new this.Node(g);a.addBefore(h)}this.length+=arguments.length,this.dispatchesRangeChanges&&(this.updateIndexes(e.next,void 0===e.index?0:e.index+1),this.dispatchRangeChange(b,c,d))},d.prototype.unshift=function(){if(this.dispatchesRangeChanges){var a=Array.prototype.slice.call(arguments),b=[];this.dispatchBeforeRangeChange(a,b,0)}for(var c=this.head,d=0;d<arguments.length;d++){var e=arguments[d],f=new this.Node(e);c.addAfter(f),c=f}this.length+=arguments.length,this.dispatchesRangeChanges&&(this.updateIndexes(this.head.next,0),this.dispatchRangeChange(a,b,0))},d.prototype.pop=function(){var a,b=this.head;if(b.prev!==b){if(a=b.prev.value,this.dispatchesRangeChanges){var c=[],d=[a],e=this.length-1;this.dispatchBeforeRangeChange(c,d,e)}b.prev.delete(),this.length--,this.dispatchesRangeChanges&&this.dispatchRangeChange(c,d,e)}return a},d.prototype.shift=function(){var a,b=this.head;if(b.prev!==b){if(a=b.next.value,this.dispatchesRangeChanges){var c=[],d=[a];this.dispatchBeforeRangeChange(c,d,0)}b.next.delete(),this.length--,this.dispatchesRangeChanges&&(this.updateIndexes(this.head.next,0),this.dispatchRangeChange(c,d,0))}return a},d.prototype.peek=function(){if(this.head!==this.head.next)return this.head.next.value},d.prototype.poke=function(a){this.head!==this.head.next?this.head.next.value=a:this.push(a)},d.prototype.one=function(){return this.peek()},d.prototype.scan=function(a,b){var c=this.head;if("number"==typeof a){var d=a;if(d>=0)for(a=c.next;d&&(d--,(a=a.next)!=c););else for(a=c;d<0&&(d++,(a=a.prev)!=c););return a}return a||b},d.prototype.slice=function(a,b){var c=[],d=this.head;for(a=this.scan(a,d.next),b=this.scan(b,d);a!==b&&a!==d;)c.push(a.value),a=a.next;return c},d.prototype.splice=function(a,b){return this.swap(a,b,Array.prototype.slice.call(arguments,2))},d.prototype.swap=function(a,b,c){var d=a;a=this.scan(a,this.head),null==b&&(b=1/0),c=Array.from(c);for(var e=[],f=a;b--&&b>=0&&f!==this.head;)e.push(f.value),f=f.next;var g,h;this.dispatchesRangeChanges&&(g=a===this.head?this.length:a.prev===this.head?0:a.index,h=a.prev,this.dispatchBeforeRangeChange(c,e,g));for(var f=a,i=0,f=a;i<e.length;i++,f=f.next)f.delete();null==d&&f===this.head&&(f=this.head.next);for(var i=0;i<c.length;i++){var j=new this.Node(c[i]);f.addBefore(j)}return this.length+=c.length-e.length,this.dispatchesRangeChanges&&(a===this.head?this.updateIndexes(this.head.next,0):this.updateIndexes(h.next,h.index+1),this.dispatchRangeChange(c,e,g)),e},d.prototype.reverse=function(){if(this.dispatchesRangeChanges){var a=this.toArray(),b=a.reversed();this.dispatchBeforeRangeChange(b,a,0)}var c=this.head;do{var d=c.next;c.next=c.prev,c.prev=d,c=c.next}while(c!==this.head);return this.dispatchesRangeChanges&&this.dispatchRangeChange(b,a,0),this},d.prototype.sort=function(){this.swap(0,this.length,this.sorted())},d.prototype.reduce=function(a,b){for(var c=arguments[2],d=this.head,e=d.next;e!==d;)b=a.call(c,b,e.value,e,this),e=e.next;return b},d.prototype.reduceRight=function(a,b){for(var c=arguments[2],d=this.head,e=d.prev;e!==d;)b=a.call(c,b,e.value,e,this),e=e.prev;return b},d.prototype.updateIndexes=function(a,b){for(;a!==this.head;)a.index=b++,a=a.next},d.prototype.makeObservable=function(){this.head.index=-1,this.updateIndexes(this.head.next,0),this.dispatchesRangeChanges=!0},d.prototype.iterate=function(){return new e(this.head)},e.prototype.next=function(){if(this.at===this.head)throw StopIteration;var a=this.at.value;return this.at=this.at.next,a},d.prototype.Node=f,f.prototype.delete=function(){this.prev.next=this.next,this.next.prev=this.prev},f.prototype.addBefore=function(a){var b=this.prev;this.prev=a,a.prev=b,b.next=a,a.next=this},f.prototype.addAfter=function(a){var b=this.next;this.next=a,a.next=b,b.prev=a,a.prev=this}},{"./generic-collection":41,"./generic-order":43,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],47:[function(a,b,c){function d(a){for(var b in a)Object.defineProperty(Array.prototype,b,{value:a[b],writable:!0,configurable:!0,enumerable:!1})}a("../shim");var e,f=(a("../list"),a("weak-map"),a("./property-changes")),g=a("./range-changes"),h=a("./map-changes"),i=Array.prototype.splice,j=Array.prototype.slice,k=(Array.prototype.reverse,Array.prototype.sort),l={}.__proto__===Object.prototype;e=l?function(){this.__proto__=n}:function(){Object.defineProperties(this,m)},Object.defineProperty(Array.prototype,"makeObservable",{value:e,writable:!0,configurable:!0,enumerable:!1}),d(f.prototype),d(g.prototype),d(h.prototype);var m={isObservable:{value:!0,writable:!0,configurable:!0},makeObservable:{value:Function.noop,writable:!0,configurable:!0},reverse:{value:function(){var a=this.constructClone(this);return a.reverse(),this.swap(0,this.length,a),this},writable:!0,configurable:!0},sort:{value:function(){this.dispatchBeforeRangeChange(this,this,0);for(var a=0;a<this.length;a++)f.dispatchBeforeOwnPropertyChange(this,a,this[a]),this.dispatchBeforeMapChange(a,this[a]);k.apply(this,arguments);for(var a=0;a<this.length;a++)f.dispatchOwnPropertyChange(this,a,this[a]),this.dispatchMapChange(a,this[a]);return this.dispatchRangeChange(this,this,0),this},writable:!0,configurable:!0},splice:{value:function(a,b){var c=j.call(this,a,a+b),d=j.call(arguments,2);if(!c.length&&!d.length)return d;var e=d.length-c.length,g=this.length,h=Math.max(this.length+e,a+d.length),k=Math.max(g,h);if(e&&f.dispatchBeforeOwnPropertyChange(this,"length",this.length),this.dispatchBeforeRangeChange(d,c,a),0===e)for(var l=a;l<a+d.length;l++)f.dispatchBeforeOwnPropertyChange(this,l,this[l]),this.dispatchBeforeMapChange(l,this[l]);else if(f.hasOwnPropertyChangeDescriptor(this))for(var l=a;l<k;l++)f.dispatchBeforeOwnPropertyChange(this,l,this[l]),this.dispatchBeforeMapChange(l,this[l]);a>g&&(this.length=a);var m=i.apply(this,arguments);if(0===e)for(var l=a;l<a+d.length;l++)f.dispatchOwnPropertyChange(this,l,this[l]),this.dispatchMapChange(l,this[l]);else if(f.hasOwnPropertyChangeDescriptor(this))for(var l=a;l<k;l++)f.dispatchOwnPropertyChange(this,l,this[l]),this.dispatchMapChange(l,this[l]);return this.dispatchRangeChange(d,c,a),e&&f.dispatchOwnPropertyChange(this,"length",this.length),m},writable:!0,configurable:!0},set:{value:function(a,b){return this.splice(a,1,b),this},writable:!0,configurable:!0},shift:{value:function(){return this.splice(0,1)[0]},writable:!0,configurable:!0},pop:{value:function(){if(this.length)return this.splice(this.length-1,1)[0]},writable:!0,configurable:!0},push:{value:function(a){if(1===arguments.length)return this.splice(this.length,0,a);var b=j.call(arguments);return this.swap(this.length,0,b)},writable:!0,configurable:!0},unshift:{value:function(a){if(1===arguments.length)return this.splice(0,0,a);var b=j.call(arguments);return this.swap(0,0,b)},writable:!0,configurable:!0},clear:{value:function(){return this.splice(0,this.length)},writable:!0,configurable:!0}},n=Object.create(Array.prototype,m)},{"../list":46,"../shim":58,"./map-changes":48,"./property-changes":49,"./range-changes":50,"weak-map":52}],48:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. MapChanges is a mixin.")}var e=a("weak-map"),f=a("../list");b.exports=d;var g=(Object.prototype.hasOwnProperty,new e);d.prototype.getAllMapChangeDescriptors=function(){var b=a("../dict");return g.has(this)||g.set(this,b()),g.get(this)},d.prototype.getMapChangeDescriptor=function(a){var b=this.getAllMapChangeDescriptors();return a=a||"",b.has(a)||b.set(a,{willChangeListeners:new f,changeListeners:new f}),b.get(a)},d.prototype.addMapChangeListener=function(a,b,c){!this.isObservable&&this.makeObservable&&this.makeObservable();var d,e=this.getMapChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners,d.push(a),Object.defineProperty(this,"dispatchesMapChanges",{value:!0,writable:!0,configurable:!0,enumerable:!1});var f=this;return function(){f&&(f.removeMapChangeListener(a,b,c),f=null)}},d.prototype.removeMapChangeListener=function(a,b,c){var d,e=this.getMapChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners;var f=d.findLast(a);if(!f)throw new Error("Can't remove listener: does not exist.");f.delete()},d.prototype.dispatchMapChange=function(a,b,c){var d="Map"+(c?"WillChange":"Change");this.getAllMapChangeDescriptors().forEach(function(e,f){if(!e.isActive){e.isActive=!0;var g;g=c?e.willChangeListeners:e.changeListeners;var h="handle"+(f.slice(0,1).toUpperCase()+f.slice(1))+d;try{g.forEach(function(c){if(c[h])c[h](b,a,this);else{if(!c.call)throw new Error("Handler "+c+" has no method "+h+" and is not callable");c.call(c,b,a,this)}},this)}finally{e.isActive=!1}}},this)},d.prototype.addBeforeMapChangeListener=function(a,b){return this.addMapChangeListener(a,b,!0)},d.prototype.removeBeforeMapChangeListener=function(a,b){return this.removeMapChangeListener(a,b,!0)},d.prototype.dispatchBeforeMapChange=function(a,b){return this.dispatchMapChange(a,b,!0)}},{"../dict":39,"../list":46,"weak-map":52}],49:[function(a,b,c){function d(){throw new Error("This is an abstract interface. Mix it. Don't construct it")}a("../shim");var e=a("weak-map"),f=Object.prototype.hasOwnProperty,g=new e,h=new e;b.exports=d,d.debug=!0,d.prototype.getOwnPropertyChangeDescriptor=function(a){g.has(this)||g.set(this,{});var b=g.get(this);return f.call(b,a)||(b[a]={willChangeListeners:[],changeListeners:[]}),b[a]},d.prototype.hasOwnPropertyChangeDescriptor=function(a){if(!g.has(this))return!1;if(!a)return!0;var b=g.get(this);return!!f.call(b,a)},d.prototype.addOwnPropertyChangeListener=function(a,b,c){this.makeObservable&&!this.isObservable&&this.makeObservable();var e,f=d.getOwnPropertyChangeDescriptor(this,a);e=c?f.willChangeListeners:f.changeListeners,d.makePropertyObservable(this,a),e.push(b);var g=this;return function(){d.removeOwnPropertyChangeListener(g,a,e,c),g=null}},d.prototype.addBeforeOwnPropertyChangeListener=function(a,b){return d.addOwnPropertyChangeListener(this,a,b,!0)},d.prototype.removeOwnPropertyChangeListener=function(a,b,c){var e,f=d.getOwnPropertyChangeDescriptor(this,a);e=c?f.willChangeListeners:f.changeListeners;var g=e.lastIndexOf(b);if(g===-1)throw new Error("Can't remove listener: does not exist.");e.splice(g,1),f.changeListeners.length+f.willChangeListeners.length===0&&d.makePropertyUnobservable(this,a)},d.prototype.removeBeforeOwnPropertyChangeListener=function(a,b){return d.removeOwnPropertyChangeListener(this,a,b,!0)},d.prototype.dispatchOwnPropertyChange=function(a,b,c){var e=d.getOwnPropertyChangeDescriptor(this,a);if(!e.isActive){e.isActive=!0;var f;f=c?e.willChangeListeners:e.changeListeners;var g=(c?"Will":"")+"Change",h="handleProperty"+g,i=String(a);i=i&&i[0].toUpperCase()+i.slice(1);var j="handle"+i+g;try{f.forEach(function(c){var d=c;if(c=c[j]||c[h]||c,!c.call)throw new Error("No event listener for "+j+" or "+h+" or call on "+c);c.call(d,b,a,this)},this)}finally{e.isActive=!1}}},d.prototype.dispatchBeforeOwnPropertyChange=function(a,b){return d.dispatchOwnPropertyChange(this,a,b,!0)},d.prototype.makePropertyObservable=function(a){if(!Array.isArray(this)){if(!Object.isExtensible(this,a))throw new Error("Can't make property "+JSON.stringify(a)+" observable on "+this+" because object is not extensible");var b;"object"==typeof this.__state__?b=this.__state__:(b={},Object.isExtensible(this,"__state__")&&Object.defineProperty(this,"__state__",{value:b,writable:!0,enumerable:!1})),b[a]=this[a],h.has(this)||(c={},h.set(this,c));var c=h.get(this);if(!f.call(c,a)){var e,g=this;Object.getOwnPropertyDescriptor(g,a);do{if(e=Object.getOwnPropertyDescriptor(g,a))break;g=Object.getPrototypeOf(g)}while(g);if(e=e||{value:void 0,enumerable:!0,writable:!0,configurable:!0},!e.configurable)throw new Error("Can't observe non-configurable properties");if(c[a]=e,e.writable||e.set){var i;i="value"in e?{get:function(){return e.value},set:function(c){return c===e.value?c:(d.dispatchBeforeOwnPropertyChange(this,a,e.value),e.value=c,b[a]=c,d.dispatchOwnPropertyChange(this,a,c),c)},enumerable:e.enumerable,configurable:!0}:{get:function(){if(e.get)return e.get.apply(this,arguments)},set:function(c){var f;return e.get&&(f=e.get.apply(this,arguments)),e.set&&e.set.apply(this,arguments),e.get&&(c=e.get.apply(this,arguments),b[a]=c),c===f?c:(d.dispatchBeforeOwnPropertyChange(this,a,f),d.dispatchOwnPropertyChange(this,a,c),c)},enumerable:e.enumerable,configurable:!0},Object.defineProperty(this,a,i)}}}},d.prototype.makePropertyUnobservable=function(a){if(!Array.isArray(this)){if(!h.has(this))throw new Error("Can't uninstall observer on property");var b=h.get(this);if(!b[a])throw new Error("Can't uninstall observer on property");var c=b[a];delete b[a];var d;"object"==typeof this.__state__?d=this.__state__:(d={},Object.isExtensible(this,"__state__")&&Object.defineProperty(this,"__state__",{value:d,writable:!0,enumerable:!1})),delete d[a],Object.defineProperty(this,a,c)}},d.getOwnPropertyChangeDescriptor=function(a,b){return a.getOwnPropertyChangeDescriptor?a.getOwnPropertyChangeDescriptor(b):d.prototype.getOwnPropertyChangeDescriptor.call(a,b)},d.hasOwnPropertyChangeDescriptor=function(a,b){return a.hasOwnPropertyChangeDescriptor?a.hasOwnPropertyChangeDescriptor(b):d.prototype.hasOwnPropertyChangeDescriptor.call(a,b)},d.addOwnPropertyChangeListener=function(a,b,c,e){if(Object.isObject(a))return a.addOwnPropertyChangeListener?a.addOwnPropertyChangeListener(b,c,e):d.prototype.addOwnPropertyChangeListener.call(a,b,c,e)},d.removeOwnPropertyChangeListener=function(a,b,c,e){if(Object.isObject(a))return a.removeOwnPropertyChangeListener?a.removeOwnPropertyChangeListener(b,c,e):d.prototype.removeOwnPropertyChangeListener.call(a,b,c,e)},d.dispatchOwnPropertyChange=function(a,b,c,e){if(Object.isObject(a))return a.dispatchOwnPropertyChange?a.dispatchOwnPropertyChange(b,c,e):d.prototype.dispatchOwnPropertyChange.call(a,b,c,e)},d.addBeforeOwnPropertyChangeListener=function(a,b,c){return d.addOwnPropertyChangeListener(a,b,c,!0)},d.removeBeforeOwnPropertyChangeListener=function(a,b,c){return d.removeOwnPropertyChangeListener(a,b,c,!0)},d.dispatchBeforeOwnPropertyChange=function(a,b,c){return d.dispatchOwnPropertyChange(a,b,c,!0)},d.makePropertyObservable=function(a,b){return a.makePropertyObservable?a.makePropertyObservable(b):d.prototype.makePropertyObservable.call(a,b)},d.makePropertyUnobservable=function(a,b){return a.makePropertyUnobservable?a.makePropertyUnobservable(b):d.prototype.makePropertyUnobservable.call(a,b)}},{"../shim":58,"weak-map":52}],50:[function(a,b,c){"use strict";function d(){throw new Error("Can't construct. RangeChanges is a mixin.")}var e=a("weak-map"),f=a("../dict"),g=new e;b.exports=d,d.prototype.getAllRangeChangeDescriptors=function(){return g.has(this)||g.set(this,f()),g.get(this)},d.prototype.getRangeChangeDescriptor=function(a){var b=this.getAllRangeChangeDescriptors();return a=a||"",b.has(a)||b.set(a,{isActive:!1,changeListeners:[],willChangeListeners:[]}),b.get(a)},d.prototype.addRangeChangeListener=function(a,b,c){!this.isObservable&&this.makeObservable&&this.makeObservable();var d,e=this.getRangeChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners,d.push(a),Object.defineProperty(this,"dispatchesRangeChanges",{value:!0,writable:!0,configurable:!0,enumerable:!1});var f=this;return function(){f&&(f.removeRangeChangeListener(a,b,c),f=null)}},d.prototype.removeRangeChangeListener=function(a,b,c){var d,e=this.getRangeChangeDescriptor(b);d=c?e.willChangeListeners:e.changeListeners;var f=d.lastIndexOf(a);if(f===-1)throw new Error("Can't remove listener: does not exist.");d.splice(f,1)},d.prototype.dispatchRangeChange=function(a,b,c,d){var e="Range"+(d?"WillChange":"Change");this.getAllRangeChangeDescriptors().forEach(function(f,g){if(!f.isActive){f.isActive=!0;var h;h=d?f.willChangeListeners:f.changeListeners;var i="handle"+(g.slice(0,1).toUpperCase()+g.slice(1))+e;try{h.forEach(function(e){if(e[i])e[i](a,b,c,this,d);else{if(!e.call)throw new Error("Handler "+e+" has no method "+i+" and is not callable");e.call(this,a,b,c,this,d)}},this)}finally{f.isActive=!1}}},this)},d.prototype.addBeforeRangeChangeListener=function(a,b){return this.addRangeChangeListener(a,b,!0)},d.prototype.removeBeforeRangeChangeListener=function(a,b){return this.removeRangeChangeListener(a,b,!0)},d.prototype.dispatchBeforeRangeChange=function(a,b,c){return this.dispatchRangeChange(a,b,c,!0)}},{"../dict":39,"weak-map":52}],51:[function(a,b,c){"use strict";function d(a,b,c,f){if(!(this instanceof d))return new d(a,b,c,f);b=b||Object.equals,c=c||Object.hash,f=f||Function.noop,this.contentEquals=b,this.contentHash=c,this.getDefault=f,this.store=new e(void 0,function(a,c){return b(a.key,c.key)},function(a){return c(a.key)}),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./set")),f=a("./generic-collection"),g=a("./generic-map"),h=a("./listen/property-changes");b.exports=d,d.Map=d,Object.addEach(d.prototype,f.prototype),Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentHash,this.getDefault)},d.prototype.log=function(a,b,c,d){b=b||this.logNode,this.store.log(a,function(a,c,d){b(a.value.value,c,d)},c,d)},d.prototype.logNode=function(a,b){b(" key: "+a.key),b(" value: "+a.value)}},{"./generic-collection":41,"./generic-map":42,"./listen/property-changes":49,"./set":53,"./shim":58}],52:[function(a,b,c){!function(){"use strict";function a(b){b.permitHostObjects___&&b.permitHostObjects___(a)}function c(a){return!(a.substr(0,j.length)==j&&"___"===a.substr(a.length-3))}function d(a){if(a!==Object(a))throw new TypeError("Not an object: "+a);var b=a[k];if(b&&b.key===a)return b;if(i(a)){return b={key:a,gets:[],vals:[]},h(a,k,{value:b,writable:!1,enumerable:!1,configurable:!1}),b}}function e(a){return a.prototype=null,Object.freeze(a)}if("undefined"==typeof ses||!ses.ok||ses.ok()){if("undefined"!=typeof ses&&(ses.weakMapPermitHostObjects=a),"function"==typeof WeakMap){var f=WeakMap;if("undefined"==typeof navigator||!/Firefox/.test(navigator.userAgent))return void(b.exports=WeakMap)}var g=(Object.prototype.hasOwnProperty,Object.getOwnPropertyNames),h=Object.defineProperty,i=Object.isExtensible,j="weakmap:",k=j+"ident:"+Math.random()+"___";if("undefined"!=typeof crypto&&"function"==typeof crypto.getRandomValues&&"function"==typeof ArrayBuffer&&"function"==typeof Uint8Array){var l=new ArrayBuffer(25),m=new Uint8Array(l);crypto.getRandomValues(m),k=j+"rand:"+Array.prototype.map.call(m,function(a){return(a%36).toString(36)}).join("")+"___"}if(h(Object,"getOwnPropertyNames",{value:function(a){return g(a).filter(c)}}),"getPropertyNames"in Object){var n=Object.getPropertyNames;h(Object,"getPropertyNames",{value:function(a){return n(a).filter(c)}})}!function(){var a=Object.freeze;h(Object,"freeze",{value:function(b){return d(b),a(b)}});var b=Object.seal;h(Object,"seal",{value:function(a){return d(a),b(a)}});var c=Object.preventExtensions;h(Object,"preventExtensions",{value:function(a){return d(a),c(a)}})}();var o=function(){function a(b,c){var e,f,i=d(b);return i?(e=i.gets.indexOf(a),f=i.vals):(e=g.indexOf(b),f=h),e>=0?f[e]:c}function b(b){var c=d(b);return(c?c.gets.indexOf(a):g.indexOf(b))>=0}function c(b,c){var e,f=d(b);f?(e=f.gets.indexOf(a),e>=0?f.vals[e]=c:(f.gets.push(a),f.vals.push(c))):(e=g.indexOf(b),e>=0?h[e]=c:(g.push(b),h.push(c)))}function f(b){var c,e=d(b);return e?(c=e.gets.indexOf(a))>=0&&(e.gets.splice(c,1),e.vals.splice(c,1)):(c=g.indexOf(b))>=0&&(g.splice(c,1),h.splice(c,1)),!0}var g=[],h=[];return Object.create(o.prototype,{get___:{value:e(a)},has___:{value:e(b)},set___:{value:e(c)},delete___:{value:e(f)}})};o.prototype=Object.create(Object.prototype,{get:{value:function(a,b){return this.get___(a,b)},writable:!0,configurable:!0},has:{value:function(a){return this.has___(a)},writable:!0,configurable:!0},set:{value:function(a,b){this.set___(a,b)},writable:!0,configurable:!0},delete:{value:function(a){return this.delete___(a)},writable:!0,configurable:!0}}),"function"==typeof f?function(){function c(){function b(a,b){return i?h.has(a)?h.get(a):i.get___(a,b):h.get(a,b)}function c(a){return h.has(a)||!!i&&i.has___(a)}function d(a,b){if(j)try{h.set(a,b)}catch(c){i||(i=new o),i.set___(a,b)}else h.set(a,b)}function g(a){h.delete(a),i&&i.delete___(a)}var h=new f,i=void 0,j=!1;return Object.create(o.prototype,{get___:{value:e(b)},has___:{value:e(c)},set___:{value:e(d)},delete___:{value:e(g)},permitHostObjects___:{value:e(function(b){if(b!==a)throw new Error("bogus call to permitHostObjects___");j=!0})}})}c.prototype=o.prototype,b.exports=c,Object.defineProperty(WeakMap.prototype,"constructor",{value:WeakMap,enumerable:!1,configurable:!0,writable:!0})}():("undefined"!=typeof Proxy&&(Proxy=void 0),b.exports=o)}}()},{}],53:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);b=b||Object.equals,c=c||Object.hash,e=e||Function.noop,this.contentEquals=b,this.contentHash=c,this.getDefault=e,this.order=new this.Order(void 0,b),this.store=new this.Store(void 0,function(a,c){return b(a.value,c.value)},function(a){return c(a.value)}),this.length=0,this.addEach(a)}var e=(a("./shim"),a("./list")),f=a("./fast-set"),g=a("./generic-collection"),h=a("./generic-set"),i=a("./listen/property-changes"),j=a("./listen/range-changes");b.exports=d,d.Set=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.Order=e,d.prototype.Store=f,d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentHash,this.getDefault)},d.prototype.has=function(a){var b=new this.order.Node(a);return this.store.has(b)},d.prototype.get=function(a){var b=new this.order.Node(a);return b=this.store.get(b),b?b.value:this.getDefault(a)},d.prototype.add=function(a){var b=new this.order.Node(a);if(!this.store.has(b)){var c=this.length;return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],c),this.order.add(a),b=this.order.head.prev,this.store.add(b),this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],c),!0}return!1},d.prototype.delete=function(a){var b=new this.order.Node(a);if(this.store.has(b)){var b=this.store.get(b);return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([],[a],b.index),this.store.delete(b),this.order.splice(b,1),this.length--,this.dispatchesRangeChanges&&this.dispatchRangeChange([],[a],b.index),!0}return!1},d.prototype.pop=function(){if(this.length){var a=this.order.head.prev.value;return this.delete(a),a}},d.prototype.shift=function(){if(this.length){var a=this.order.head.next.value;return this.delete(a),a}},d.prototype.one=function(){if(this.length>0)return this.store.one().value},d.prototype.clear=function(){var a;this.dispatchesRangeChanges&&(a=this.toArray(),this.dispatchBeforeRangeChange([],a,0)),this.store.clear(),this.order.clear(),this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange([],a,0)},d.prototype.reduce=function(a,b){var c=arguments[2],d=0;return this.order.reduce(function(b,e){return a.call(c,b,e,d++,this)},b,this)},d.prototype.reduceRight=function(a,b){var c=arguments[2],d=this.order,e=this.length-1;return d.reduceRight(function(b,d){return a.call(c,b,d,e--,this)},b,this)},d.prototype.iterate=function(){return this.order.iterate()},d.prototype.log=function(){var a=this.store;return a.log.apply(a,arguments)},d.prototype.makeObservable=function(){this.order.makeObservable()}},{"./fast-set":40,"./generic-collection":41,"./generic-set":44,"./list":46,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],54:[function(a,b,c){"use strict";function d(a,b){Object.defineProperty(Array.prototype,a,{value:b,writable:!0,configurable:!0,enumerable:!1})}function e(a,b,c){this.array=a,this.start=null==b?0:b,this.end=c}var f=(a("./shim-function"),a("./generic-collection")),g=a("./generic-order"),h=a("weak-map");b.exports=Array,Array.empty=[],Object.freeze&&Object.freeze(Array.empty),Array.from=function(a){var b=[];return b.addEach(a),b},Array.unzip=function(a){for(var b=[],c=1/0,d=0;d<a.length;d++){var e=a[d];a[d]=e.toArray(),e.length<c&&(c=e.length)}for(var d=0;d<a.length;d++)for(var e=a[d],f=0;f<e.length;f++)f<c&&f in e&&(b[f]=b[f]||[],b[f][d]=e[f]);return b},d("addEach",f.prototype.addEach),d("deleteEach",f.prototype.deleteEach),d("toArray",f.prototype.toArray),d("toObject",f.prototype.toObject),d("all",f.prototype.all),d("any",f.prototype.any),d("min",f.prototype.min),d("max",f.prototype.max),d("sum",f.prototype.sum),d("average",f.prototype.average),d("only",f.prototype.only),d("flatten",f.prototype.flatten),d("zip",f.prototype.zip),d("enumerate",f.prototype.enumerate),d("group",f.prototype.group),d("sorted",f.prototype.sorted),
+d("reversed",f.prototype.reversed),d("constructClone",function(a){var b=new this.constructor;return b.addEach(a),b}),d("has",function(a,b){return this.find(a,b)!==-1}),d("get",function(a,b){if(+a!==a)throw new Error("Indicies must be numbers");return!a in this?b:this[a]}),d("set",function(a,b){return this.splice(a,1,b),!0}),d("add",function(a){return this.push(a),!0}),d("delete",function(a,b){var c=this.find(a,b);return c!==-1&&(this.splice(c,1),!0)}),d("find",function(a,b){b=b||this.contentEquals||Object.equals;for(var c=0;c<this.length;c++)if(c in this&&b(this[c],a))return c;return-1}),d("findLast",function(a,b){b=b||this.contentEquals||Object.equals;var c=this.length;do{if(--c in this&&b(this[c],a))return c}while(c>0);return-1}),d("swap",function(a,b,c){var d=Array.prototype.slice.call(arguments,0,2);return c&&(Array.isArray(c)||(c=Array.prototype.slice.call(c)),d.push.apply(d,c)),this.splice.apply(this,d)}),d("one",function(){for(var a in this)if(Object.owns(this,a))return this[a]}),d("clear",function(){return this.length=0,this}),d("compare",function(a,b){b=b||Object.compare;var c,d,e,f,h;if(this===a)return 0;if(!a||!Array.isArray(a))return g.prototype.compare.call(this,a,b);for(d=Math.min(this.length,a.length),c=0;c<d;c++)if(c in this){if(!(c in a))return-1;if(e=this[c],f=a[c],h=b(e,f))return h}else if(c in a)return 1;return this.length-a.length}),d("equals",function(a,b){b=b||Object.equals;var c,d,e=0,f=this.length;if(this===a)return!0;if(!a||!Array.isArray(a))return g.prototype.equals.call(this,a);if(f!==a.length)return!1;for(;e<f;++e)if(e in this){if(!(e in a))return!1;if(c=this[e],d=a[e],!b(c,d))return!1}else if(e in a)return!1;return!0}),d("clone",function(a,b){if(void 0===a)a=1/0;else if(0===a)return this;b=b||new h;var c=[];for(var d in this)Object.owns(this,d)&&(c[d]=Object.clone(this[d],a-1,b));return c}),d("iterate",function(a,b){return new e(this,a,b)}),d("Iterator",e),e.prototype.next=function(){if(this.start===(null==this.end?this.array.length:this.end))throw StopIteration;return this.array[this.start++]}},{"./generic-collection":41,"./generic-order":43,"./shim-function":55,"weak-map":52}],55:[function(a,b,c){arguments[4][19][0].apply(c,arguments)},{dup:19}],56:[function(a,b,c){"use strict";var d=a("weak-map");b.exports=Object,Object.empty=Object.freeze(Object.create(null)),Object.isObject=function(a){return Object(a)===a},Object.getValueOf=function(a){return Object.can(a,"valueOf")&&(a=a.valueOf()),a};var e=new d;Object.hash=function(a){return Object.can(a,"hash")?""+a.hash():Object(a)===a?(e.has(a)||e.set(a,Math.random().toString(36).slice(2)),e.get(a)):""+a};var f=Object.prototype.hasOwnProperty;Object.owns=function(a,b){return f.call(a,b)},Object.can=function(a,b){return null!=a&&"function"==typeof a[b]&&!f.call(a,b)},Object.has=function(a,b){if("object"!=typeof a)throw new Error("Object.has can't accept non-object: "+typeof a);if(Object.can(a,"has"))return a.has(b);if("string"==typeof b)return b in a&&a[b]!==Object.prototype[b];throw new Error("Key must be a string for Object.has on plain objects")},Object.get=function(a,b,c){if("object"!=typeof a)throw new Error("Object.get can't accept non-object: "+typeof a);return Object.can(a,"get")?a.get(b,c):Object.has(a,b)?a[b]:c},Object.set=function(a,b,c){Object.can(a,"set")?a.set(b,c):a[b]=c},Object.addEach=function(a,b){return b&&(Object.can(b,"forEach")?"function"==typeof b.keys?b.forEach(function(b,c){a[c]=b}):b.forEach(function(b){a[b[0]]=b[1]}):Object.keys(b).forEach(function(c){a[c]=b[c]})),a},Object.forEach=function(a,b,c){Object.keys(a).forEach(function(d){b.call(c,a[d],d,a)})},Object.map=function(a,b,c){return Object.keys(a).map(function(d){return b.call(c,a[d],d,a)})},Object.values=function(a){return Object.map(a,Function.identity)},Object.concat=function(){for(var a={},b=0;b<arguments.length;b++)Object.addEach(a,arguments[b]);return a},Object.from=Object.concat,Object.is=function(a,b){return a===b?0!==a||1/a==1/b:a!==a&&b!==b},Object.equals=function(a,b,c){if(c=c||Object.equals,a=Object.getValueOf(a),b=Object.getValueOf(b),a===b)return 0!==a||1/a==1/b;if(null===a||null===b)return a===b;if(Object.can(a,"equals"))return a.equals(b,c);if(Object.can(b,"equals"))return b.equals(a,c);if("object"==typeof a&&"object"==typeof b){var d=Object.getPrototypeOf(a);if(d===Object.getPrototypeOf(b)&&(d===Object.prototype||null===d)){for(var e in a)if(!c(a[e],b[e]))return!1;for(var e in b)if(!c(a[e],b[e]))return!1;return!0}}return a!==a&&b!==b},Object.compare=function(a,b){a=Object.getValueOf(a),b=Object.getValueOf(b);var c=typeof a,d=typeof b;return a===b?0:c!==d?0:"number"===c?a-b:"string"===c?a<b?-1:1:Object.can(a,"compare")?a.compare(b):Object.can(b,"compare")?-b.compare(a):0},Object.clone=function(a,b,c){if(a=Object.getValueOf(a),c=c||new d,void 0===b)b=1/0;else if(0===b)return a;if(Object.isObject(a)){if(!c.has(a))if(Object.can(a,"clone"))c.set(a,a.clone(b,c));else{var e=Object.getPrototypeOf(a);if(null!==e&&e!==Object.prototype)throw new Error("Can't clone "+a);var f=Object.create(e);c.set(a,f);for(var g in a)f[g]=Object.clone(a[g],b-1,c)}return c.get(a)}return a},Object.clear=function(a){if(Object.can(a,"clear"))a.clear();else for(var b=Object.keys(a),c=b.length;c;)c--,delete a[b[c]];return a}},{"weak-map":52}],57:[function(a,b,c){arguments[4][21][0].apply(c,arguments)},{dup:21}],58:[function(a,b,c){arguments[4][22][0].apply(c,arguments)},{"./shim-array":54,"./shim-function":55,"./shim-object":56,"./shim-regexp":57,dup:22}],59:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);Array.isArray(a)?(this.array=a,a=a.splice(0,a.length)):this.array=[],this.contentEquals=b||Object.equals,this.contentCompare=c||Object.compare,this.getDefault=e||Function.noop,this.length=0,this.addEach(a)}function e(a,b,c){for(var d=0,e=a.length-1;d<=e;){var f=d+e>>1,g=c(b,a[f]);if(g>0)d=f+1;else{if(!(g<0))return f;e=f-1}}return-(d+1)}function f(a,b,c,d){var f=e(a,b,c);if(f<0)return-1;for(;f>0&&d(b,a[f-1]);)f--;return d(b,a[f])?f:-1}function g(a,b,c,d){var f=e(a,b,c);if(f<0)return-1;for(;f<a.length-1&&d(b,a[f+1]);)f++;return d(b,a[f])?f:-1}function h(a,b,c){var d=e(a,b,c);if(d<0)return-d-1;for(var f=a.length-1;d<f&&0===c(b,a[d+1]);)d++;return d}b.exports=d;var i=(a("./shim"),a("./generic-collection")),j=a("./listen/property-changes"),k=a("./listen/range-changes");d.SortedArray=d,Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),Object.addEach(d.prototype,k.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentCompare,this.getDefault)},d.prototype.has=function(a){var b=e(this.array,a,this.contentCompare);return b>=0&&this.contentEquals(this.array[b],a)},d.prototype.get=function(a){var b=f(this.array,a,this.contentCompare,this.contentEquals);return b!==-1?this.array[b]:this.getDefault(a)},d.prototype.add=function(a){var b=h(this.array,a,this.contentCompare);return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],b),this.array.splice(b,0,a),this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],b),!0},d.prototype.delete=function(a){var b=f(this.array,a,this.contentCompare,this.contentEquals);return b!==-1&&(this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([],[a],b),this.array.splice(b,1),this.length--,this.dispatchesRangeChanges&&this.dispatchRangeChange([],[a],b),!0)},d.prototype.indexOf=function(a){return f(this.array,a,this.contentCompare,this.contentEquals)},d.prototype.lastIndexOf=function(a){return g(this.array,a,this.contentCompare,this.contentEquals)},d.prototype.find=function(a){return f(this.array,a,this.contentCompare,this.contentEquals)},d.prototype.findLast=function(a){return g(this.array,a,this.contentCompare,this.contentEquals)},d.prototype.push=function(){this.addEach(arguments)},d.prototype.unshift=function(){this.addEach(arguments)},d.prototype.pop=function(){return this.array.pop()},d.prototype.shift=function(){return this.array.shift()},d.prototype.slice=function(){return this.array.slice.apply(this.array,arguments)},d.prototype.splice=function(a,b){return this.swap(a,b,Array.prototype.slice.call(arguments,2))},d.prototype.swap=function(a,b,c){if(void 0===a&&void 0===b)return[];a=a||0,a<0&&(a+=this.length),void 0===b&&(b=1/0);var d=this.slice(a,a+b);return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange(c,d,a),this.array.splice(a,b),this.addEach(c),this.dispatchesRangeChanges&&this.dispatchRangeChange(c,d,a),d},d.prototype.reduce=function(a,b){var c=arguments[2];return this.array.reduce(function(b,d,e){return a.call(c,b,d,e,this)},b,this)},d.prototype.reduceRight=function(){var a=arguments[2];return this.array.reduceRight(function(b,c,d){return callback.call(a,b,c,d,this)},basis,this)},d.prototype.min=function(){if(this.length)return this.array[0]},d.prototype.max=function(){if(this.length)return this.array[this.length-1]},d.prototype.one=function(){return this.array.one()},d.prototype.clear=function(){var a;this.dispatchesRangeChanges&&(a=this.array.slice(),this.dispatchBeforeRangeChange([],a,0)),this.length=0,this.array.clear(),this.dispatchesRangeChanges&&this.dispatchRangeChange([],a,0)},d.prototype.equals=function(a,b){return this.array.equals(a,b)},d.prototype.compare=function(a,b){return this.array.compare(a,b)},d.prototype.iterate=function(a,b){return new this.Iterator(this.array,a,b)},d.prototype.Iterator=Array.prototype.Iterator},{"./generic-collection":41,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58}],60:[function(a,b,c){"use strict";function d(a,b,c,e){if(!(this instanceof d))return new d(a,b,c,e);this.contentEquals=b||Object.equals,this.contentCompare=c||Object.compare,this.getDefault=e||Function.noop,this.root=null,this.length=0,this.addEach(a)}function e(a){this.value=a,this.left=null,this.right=null,this.length=1}function f(a,b,c){if(this.set=a,this.prev=null,this.end=c,b){var d=this.set.findLeastGreaterThanOrEqual(b);d&&(this.set.splay(d.value),this.prev=d.getPrevious())}}b.exports=d;var g=(a("./shim"),a("./generic-collection")),h=a("./generic-set"),i=a("./listen/property-changes"),j=a("./listen/range-changes"),k=a("./tree-log");d.SortedSet=d,Object.addEach(d.prototype,g.prototype),Object.addEach(d.prototype,h.prototype),Object.addEach(d.prototype,i.prototype),Object.addEach(d.prototype,j.prototype),d.prototype.constructClone=function(a){return new this.constructor(a,this.contentEquals,this.contentCompare,this.getDefault)},d.prototype.has=function(a){return!!this.root&&(this.splay(a),this.contentEquals(a,this.root.value))},d.prototype.get=function(a){return this.root&&(this.splay(a),this.contentEquals(a,this.root.value))?this.root.value:this.getDefault(a)},d.prototype.add=function(a){var b=new this.Node(a);if(!this.root)return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],0),this.root=b,this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],0),!0;if(this.splay(a),!this.contentEquals(a,this.root.value)){var c=this.contentCompare(a,this.root.value);if(0===c)throw new Error("SortedSet cannot contain incomparable but inequal values: "+a+" and "+this.root.value);return this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([a],[],this.root.index),c<0?(b.right=this.root,b.left=this.root.left,this.root.left=null,this.root.touch()):(b.left=this.root,b.right=this.root.right,this.root.right=null,this.root.touch()),b.touch(),this.root=b,this.length++,this.dispatchesRangeChanges&&this.dispatchRangeChange([a],[],this.root.index),!0}return!1},d.prototype.delete=function(a){if(this.root&&(this.splay(a),this.contentEquals(a,this.root.value))){var b=this.root.index;if(this.dispatchesRangeChanges&&this.dispatchBeforeRangeChange([],[a],b),this.root.left){var c=this.root.right;this.root=this.root.left,this.splay(a),this.root.right=c}else this.root=this.root.right;return this.length--,this.root&&this.root.touch(),this.dispatchesRangeChanges&&this.dispatchRangeChange([],[a],b),!0}return!1},d.prototype.indexOf=function(a){return this.root&&(this.splay(a),this.contentEquals(a,this.root.value))?this.root.index:-1},d.prototype.find=function(a){if(this.root&&(this.splay(a),this.contentEquals(a,this.root.value)))return this.root},d.prototype.findGreatest=function(a){if(this.root){for(a=a||this.root;a.right;)a=a.right;return a}},d.prototype.findLeast=function(a){if(this.root){for(a=a||this.root;a.left;)a=a.left;return a}},d.prototype.findGreatestLessThanOrEqual=function(a){if(this.root)return this.splay(a),this.root},d.prototype.findGreatestLessThan=function(a){if(this.root)return this.splay(a),this.root.getPrevious()},d.prototype.findLeastGreaterThanOrEqual=function(a){if(this.root){this.splay(a);return 0===this.contentCompare(a,this.root.value)?this.root:this.root.getNext()}},d.prototype.findLeastGreaterThan=function(a){if(this.root){this.splay(a);this.contentCompare(a,this.root.value);return this.root.getNext()}},d.prototype.pop=function(){if(this.root){var a=this.findGreatest();return this.delete(a.value),a.value}},d.prototype.shift=function(){if(this.root){var a=this.findLeast();return this.delete(a.value),a.value}},d.prototype.push=function(){this.addEach(arguments)},d.prototype.unshift=function(){this.addEach(arguments)},d.prototype.slice=function(a,b){a=a||0,b=b||this.length,a<0&&(a+=this.length),b<0&&(b+=this.length);var c=[];if(this.root)for(this.splayIndex(a);this.root.index<b&&(c.push(this.root.value),this.root.right);)this.splay(this.root.getNext().value);return c},d.prototype.splice=function(a,b){return this.swap(a,b,Array.prototype.slice.call(arguments,2))},d.prototype.swap=function(a,b,c){if(void 0===a&&void 0===b)return[];a=a||0,a<0&&(a+=this.length),void 0===b&&(b=1/0);var d=[];if(this.root){this.splayIndex(a);for(var e=0;e<b;e++){d.push(this.root.value);var f=this.root.getNext();if(this.delete(this.root.value),!f)break;this.splay(f.value)}}return this.addEach(c),d},d.prototype.splay=function(a){var b,c,d,f,g,h;if(this.root){for(b=c=d=new this.Node,h=new this.Node,g=this.root;;){var i=this.contentCompare(a,g.value);if(i<0){if(!g.left)break;if(this.contentCompare(a,g.left.value)<0&&(f=g.left,g.left=f.right,g.touch(),f.right=g,f.touch(),g=f,!g.left))break;f=new e,f.right=g,f.left=h.left,h.left=f,d.left=g,d.touch(),d=g,g=g.left}else{if(!(i>0))break;if(!g.right)break;if(this.contentCompare(a,g.right.value)>0&&(f=g.right,g.right=f.left,g.touch(),f.left=g,f.touch(),g=f,!g.right))break;f=new e,f.left=g,f.right=h.right,h.right=f,c.right=g,c.touch(),c=g,g=g.right}}for(c.right=g.left,c.touch(),d.left=g.right,d.touch(),g.left=b.right,g.right=b.left;h.left;)h.left.right.touch(),h.left=h.left.left;for(;h.right;)h.right.left.touch(),h.right=h.right.right;g.touch(),this.root=g}},d.prototype.splayIndex=function(a){if(this.root){for(var b=this.root,c=this.root.index;c!==a;)if(c>a&&b.left)b=b.left,c-=1+(b.right?b.right.length:0);else{if(!(c<a&&b.right))break;b=b.right,c+=1+(b.left?b.left.length:0)}return this.splay(b.value),this.root.index===a}return!1},d.prototype.reduce=function(a,b,c){return this.root&&(b=this.root.reduce(a,b,0,c,this)),b},d.prototype.reduceRight=function(a,b,c){return this.root&&(b=this.root.reduceRight(a,b,this.length-1,c,this)),b},d.prototype.min=function(a){var b=this.findLeast(a);if(b)return b.value},d.prototype.max=function(a){var b=this.findGreatest(a);if(b)return b.value},d.prototype.one=function(){return this.min()},d.prototype.clear=function(){var a;this.dispatchesRangeChanges&&(a=this.toArray(),this.dispatchBeforeRangeChange([],a,0)),this.root=null,this.length=0,this.dispatchesRangeChanges&&this.dispatchRangeChange([],a,0)},d.prototype.iterate=function(a,b){return new this.Iterator(this,a,b)},d.prototype.Iterator=f,d.prototype.summary=function(){return this.root?this.root.summary():"()"},d.prototype.log=function(a,b,c,d){a=a||k.unicodeRound,b=b||this.logNode,c||(c=console.log,d=console),c=c.bind(d),this.root&&this.root.log(a,b,c,c)},d.prototype.logNode=function(a,b,c){b(" "+a.value)},d.logCharsets=k,d.prototype.Node=e,e.prototype.reduce=function(a,b,c,d,e,f){if(f=f||0,this.left){var g=this.left.length;b=this.left.reduce(a,b,c,d,e,f+1),c+=g}return b=a.call(d,b,this.value,c,e,this,f),c+=1,this.right&&(b=this.right.reduce(a,b,c,d,e,f+1)),b},e.prototype.reduceRight=function(a,b,c,d,e,f){return f=f||0,this.right&&(b=this.right.reduce(a,b,c,d,e,f+1),c-=this.right.length),b=a.call(d,b,this.value,this.value,e,this,f),c-=1,this.left&&(b=this.left.reduce(a,b,c,d,e,f+1)),b},e.prototype.touch=function(){this.length=1+(this.left?this.left.length:0)+(this.right?this.right.length:0),this.index=this.left?this.left.length:0},e.prototype.checkIntegrity=function(){var a=1;if(a+=this.left?this.left.checkIntegrity():0,a+=this.right?this.right.checkIntegrity():0,this.length!==a)throw new Error("Integrity check failed: "+this.summary());return a},e.prototype.getNext=function(){var a=this;if(a.right){for(a=a.right;a.left;)a=a.left;return a}},e.prototype.getPrevious=function(){var a=this;if(a.left){for(a=a.left;a.right;)a=a.right;return a}},e.prototype.summary=function(){var a=this.value||"-";return a+=" <"+this.length,this.left||this.right?"("+a+" "+(this.left?this.left.summary():"()")+", "+(this.right?this.right.summary():"()")+")":"("+a+")"},e.prototype.log=function(a,b,c,d){var e,f=this;e=this.left&&this.right?a.intersection:this.left?a.branchUp:this.right?a.branchDown:a.through;var g;this.left&&this.left.log(a,b,function(b){g?d(a.strafe+" "+b):(g=!0,d(a.fromBelow+a.through+b))},function(a){d("  "+a)});var h;b(this,function(b){h?c((f.right?a.strafe:" ")+b):(h=!0,c(e+b))},function(b){d((f.left?a.strafe:" ")+b)});var i;this.right&&this.right.log(a,b,function(b){i?c("  "+b):(i=!0,c(a.fromAbove+a.through+b))},function(b){c(a.strafe+" "+b)})},f.prototype.next=function(){var a;if(!(a=this.prev?this.set.findLeastGreaterThan(this.prev.value):this.set.findLeast()))throw StopIteration;if(void 0!==this.end&&this.set.contentCompare(a.value,this.end)>=0)throw StopIteration;return this.prev=a,a.value}},{"./generic-collection":41,"./generic-set":44,"./listen/property-changes":49,"./listen/range-changes":50,"./shim":58,"./tree-log":61}],61:[function(a,b,c){arguments[4][24][0].apply(c,arguments)},{dup:24}],62:[function(a,b,c){function d(a,b,c){var d;d="function"==typeof c?{change:c}:c,d=d||j,d.source=a,d.sourcePath=b;var k=d.parameters=d.parameters||a,l=d.document,m=d.components,n=d.beforeChange,o=d.contentChange,p=new i(a);p.parameters=k,p.document=l,p.components=m,p.beforeChange=n;var q=e(b),r=f(q);return o===!0&&(r=g.makeRangeContentObserver(r)),r(h(function(b){if(b){if("function"!=typeof o)return d.change.apply(a,arguments);if("function"==typeof o)return b.addRangeChangeListener(o),function(){b.removeRangeChangeListener(o)}}else;}),p)}var e=a("./parse"),f=a("./compile-observer"),g=a("./observers"),h=g.autoCancelPrevious,i=a("./scope");b.exports=d;var j={}},{"./compile-observer":33,"./observers":63,"./parse":65,"./scope":66}],63:[function(a,b,c){function d(a){return function(b){return b(a)}}function e(a,b){return a(b.value)}function f(a,b){return a(b.parameters)}function g(a){return function(b,c){return b(c.document.getElementById(a))}}function h(a,b){return function(c,d){var e=d.components,f=e.getObjectByLabel||e.getComponentByLabel,g=f.call(e,a);return b.component=g,c(g)}}function i(a,b,c,d){function e(a,b,d){f(),f=c(a,b,d)||Function.noop}if(null==a)return c();var f=Function.noop;return ya.addOwnPropertyChangeListener(a,b,e,d.beforeChange),e(a[b],b,a),function(){f(),ya.removeOwnPropertyChangeListener(a,b,e,d.beforeChange)}}function j(a,b){return function(c,d){return b(function(b){return"string"!=typeof b&&"number"!=typeof b?c():a(function(a){return null==a?c():a.observeProperty?a.observeProperty(b,c,d):Ea(a,b,c,d)},d)},d)}}function k(a,b,c,d){function e(a,d,e){g(b,d)&&(f(),f=c(a,b,e)||Function.noop)}var f=Function.noop,g=a.contentEquals||Object.equals;return e(a.get(b),b,a),a.addMapChangeListener(e,d.beforeChange),function(){f(),a.removeMapChangeListener(e)}}function l(a,b){return function(c,d){return a(function(a){return a?b(function(b){return null==b?c():a.observeGet?a.observeGet(b,c,d):Fa(a,b,c,d)},d):c()},d)}}function m(a,b){return function(c,d){return c=va(c),b(function(b){return a(function(a){return a?$(a,function(){return c((a.has||a.contains).call(a,b))},d):c()},d)},d)}}function n(a){return function(b,c){for(var d=Array(a.length),e=0;e<a.length;e++)d[e]=void 0;var f=a.map(function(a,b){return a(function(a){d.set(b,a)},c)}),g=b(d)||Function.noop;return function(){g(),wa(f)}}}function o(a){return function(b,c){var d={},e={};for(var f in a)!function(a,b){d[a]=b(function(b){e[a]=b},c)}(f,a[f]);var g=b(e)||Function.noop;return function(){g();for(var a in d)d[a]()}}}function p(){return n(Array.prototype.slice.call(arguments))}function q(a){return function(){var b=n(Array.prototype.slice.call(arguments)),c=fa(b);return function(b,d){return c(function(c){return c.every(Da.defined)?b(a.apply(void 0,c)):b()},d)}}}function r(a){var b=a.slice(0,1).toUpperCase()+a.slice(1),c="make"+b+"Observer",d="observe"+b;return function(){var b=arguments[0],e=Array.prototype.slice.call(arguments,1),f=n(e),g=fa(f);return function(f,h){return b(function(b){return b?b[c]?b[c].apply(b,e)(f,h):b[d]?b[d](f,h):g(function(c){return c.every(Da.defined)&&"function"==typeof b[a]?f(b[a].apply(b,c)):f()},h):f()},h)}}}function s(a){return function(b,c){return a(function(a){return b(!a)},c)}}function t(a,b){return function(c,d){return a(function(a){return a?b(c,d):c(a)},d)}}function u(a,b){return function(c,d){return a(function(a){return a?c(a):b(c,d)},d)}}function v(a,b,c){return function(d,e){return a(function(a){return null==a?d():a?b(d,e):c(d,e)},e)}}function w(a){return function(b,c){return a(function(a){return b(null!=a)},c)}}function x(a,b){return function(c,d){return a(function(a){return null==a?b(c,d):c(a)},d)}}function y(a,b){return function(c,d){return a(function(a){function e(b){for(;b<a.length;b++)h[b].index=b}function f(a,c,f){h.swap(f,c.length,a.map(function(a,b){return{index:f+b}})),e(f+a.length);var j,k=[];wa(i.swap(f,c.length,a.map(function(a,c){var e=h[f+c];return b(function(a){j?g.set(e.index,a):k[c]=a},d.nest(a))}))),j=!0,g.swap(f,c.length,k)}if(!a)return c();var g=[],h=[],i=[],j=$(a,f,d),k=c(g,a)||Function.noop;return function(){k(),wa(i),j()}},d)}}function z(a,b){var c=y(a,b);return function(a,b){return c(function(c,d){function e(a){for(;a<c.length;a++)i[a+1]=i[a]+!!c[a]}function f(a,b,c){var f=d.slice(c,c+a.length),h=b.map(Boolean).sum(),j=f.filter(function(b,c){return a[c]}),k=i[c],l=g.slice(k,k+h);(l.length!==j.length||l.some(function(a,b){return a!==j[b]}))&&g.swap(k,h,j),e(k)}if(!d)return a();var g=[],h=[],i=[0],j=$(c,f,b),k=a(g)||Function.noop;return function(){k(),wa(h),j()}},b)}}function A(a,b){var c=D(b),d=y(a,c);return Ga(function(a,b){return d(function(c){function d(a,b){f.deleteEach(b),f.addEach(a)}if(!c)return a();var e=[],f=za(e,B,C),g=$(c,d,b),h=a(e)||Function.noop;return function(){h(),g()}},b)},la)}function B(a,b){return Object.equals(a[1],b[1])}function C(a,b){return Object.compare(a[1],b[1])}function D(a){return function(b,c){return a(function(a){return b([c.value,a])},c)}}function E(a,b){var c=D(b),d=y(a,c),e=K(d,na),f=y(e,_(na));return function(a,b){function c(a,b){return a=h.get(a),b=h.get(b),Object.compare(a,b)}function d(a,b){return a=h.get(a),b=h.get(b),Object.equals(a,b)}function e(a,b){b.forEach(function(a){i.delete(a[0]),h.delete(a[0])}),a.forEach(function(a){h.set(a[0],a[1]),i.add(a[0])})}function g(a){return i.clear(),$(a,e,b)}var h=new Ba,i=new Aa(null,d,c),j=a(i)||Function.noop,k=f(g,b);return function(){j(),k()}}}function F(a){return function(b,c){return a(function(a){function d(a,b,c){var d=e.length-c-b.length;e.swap(d,b.length,a.reversed())}if(!a)return b();var e=[],f=$(a,d,c),g=b(e);return function(){g(),f()}},c)}}function G(a){return function(b,c){return a(function(a){function d(b){for(var c=b;c<a.length;c++)i[c].index=c,a[c]?h[c+1]=h[c]+a[c].length:h[c+1]=h[c]}function e(a,b,e){var j=h[e],k=h[e+b.length],l=k-j;f.swap(j,l,[]),i.swap(e,b.length,a.map(function(){return{index:null}})),d(e),wa(g.swap(e,b.length,a.map(function(a,b){function g(a,b,c){d(j.index);var e=h[j.index]+c,g=h[j.index]+c+b.length,i=g-e;f.swap(e,i,a)}var j=i[e+b];return $(a,g,c)})))}if(!a)return b();var f=[],g=[],h=[0],i=[],j=$(a,e,c),k=b(f)||Function.noop;return function(){k(),wa(g),j()}},c)}}function H(){return Ia(n(Array.prototype.slice.call(arguments)))}function I(a,b){return qa(j(Ha(a,b),Ja),Boolean)}function J(a,b){return qa(j(Ha(a,qa(b,Da.not)),Ja),Da.not)}function K(a,b){return Na(L(a,b))}function L(a,b){var c=D(b),d=y(a,c);return function(a,b){return d(function(c,d){function e(a,b,c){b.forEach(function(a){var b=f.get(a[1]);1===b.length?f.delete(a[1]):b.delete(a[0])}),a.forEach(function(a){var b,c=!f.has(a[1]);b=c?d.constructClone():f.get(a[1]),b.add(a[0]),c&&f.set(a[1],b)})}if(!c)return a();var f=Ba(),g=$(c,e,b),h=a(f)||Function.noop;return function(){g(),h()}},b)}}function M(a,b,c){function d(a,b){return Object.compare(a[1],b[1])*c}var e=D(b),f=y(a,e);return function(a,b){return f(function(c){function e(a,b){g.addEach(a),g.deleteEach(b)}function f(b,c){if(0===c)return b?a(b[0]):a()}if(!c)return a();var g=new Ca(null,B,d),h=$(c,e,b),i=ha(g,f,b);return function(){h(),i()}},b)}}function N(a,b){return M(a,b,1)}function O(a,b){return M(a,b,-1)}function P(a){return M(a,e,1)}function Q(a){return M(a,e,-1)}function R(a){return function(b){return function(c,d){return c=va(c),b(function(b){if(!b)return c();var e=a(b,c);return $(b,function(a,b,d){return c(e(a,b,d))},d)},d)}}}function S(a){return"number"==typeof a&&!isNaN(a)}function T(a,b,c){return c||(c=b,b=Ka),function(d,e){return a(function(a){function f(b,c,d){if(l){var e=b.length-c.length;d<=h?e>0?(k.swap(0,0,a.slice(h,h+e)),k.splice(g,k.length-g)):(k.splice(0,-e),k.swap(k.length,0,a.slice(h+k.length,h+g))):d<h+g&&(k.swap(d-h,c.length,b),e>0?k.splice(g,k.length-g):k.swap(k.length,0,a.slice(h+k.length,h+g)))}}if(!a)return d();var g,h,i,j,k=[],l=!1,m=$(a,f,e),n=c(function(b){b=+b,isNaN(b)&&(b=void 0);var c="number"==typeof b&&"number"==typeof h,d=Math.max(0,b);"number"==typeof j&&(d=Math.min(d,a.length-j)),l!==c?(c?k.swap(0,0,a.slice(j,j+d)):k.clear(),l=c):l&&i!==d&&(d<i?k.splice(b,i-d):k.swap(i,0,a.slice(j+i,j+d))),g=b,i=d},e),o=b(function(b){b=+b,isNaN(b)&&(b=void 0);var c="number"==typeof g&&"number"==typeof b,d=Math.max(0,b);"number"==typeof g&&(d=Math.min(d,a.length));var e=Math.max(0,g);if("number"==typeof d&&(e=Math.min(e,a.length-d)),l!==c)c?k.swap(0,k.length,a.slice(d,d+e)):k.clear(),l=c;else if(l&&j!==d){var f=Math.abs(d-j);f<i&&d<j?(k.swap(0,0,a.slice(d,j)),k.splice(e,k.length-e)):f<i&&d>j?(k.swap(k.length,0,a.slice(j+i,d+e)),k.splice(0,k.length-e)):k.swap(0,k.length,a.slice(d,d+e))}h=b,j=d,i=e},e),p=d(k)||Function.noop;return function(){p(),n(),o(),m()}},e)}}function U(a){return function(b,c){return a(function(a){function d(a){for(;a<f.length;a++)f[a].set(0,a)}function e(a,b,c){f.swap(c,b.length,a.map(function(a,b){return[c+b,a]})),d(c+a.length)}if(!a)return b();var f=[],g=$(a,e,c),h=b(f)||Function.noop;return function(){h(),g()}},c)}}function V(a){return function(b,c){var d=[],e=b(d)||Function.noop,f=a(function(a){if(null==(a>>>=0))d.clear();else if(a>d.length){for(var b=[],c=d.length;c<a;c++)b.push(c);d.swap(d.length,0,b)}else a<d.length&&d.splice(a,d.length)},c)||Function.noop;return function(){e(),f()}}}function W(a,b){return function(c,d){return b(function(b){var e=new RegExp("^"+RegExp.escape(b));return a(function(a){return c(e.test(a))},d)},d)}}function X(a,b){return function(c,d){return b(function(b){var e=new RegExp(RegExp.escape(b)+"$");return a(function(a){return c(e.test(a))},d)},d)}}function Y(a,b){return function(c,d){return b(function(b){var e=new RegExp(RegExp.escape(b));return a(function(a){return c(e.test(a))},d)},d)}}function Z(a,b){return b=b||La,function(c,d){return a(function(a){return a?b(function(b){function e(){f=c(a.join(b))||Function.noop}if("string"!=typeof b)return c();var f=Function.noop,g=$(a,e,d);return function(){g(),f()}},d):c()},d)}}function $(a,b,c){function d(a,c,d){e(),e=b(a,c,d)||Function.noop}if(!a)return Function.noop;var e=Function.noop;if(!a.toArray)return Function.noop;if(!a.addRangeChangeListener)return Function.noop;d(a.toArray(),[],0);var f=a.addRangeChangeListener(d,null,c.beforeChange);return function(){e(),f()}}function _(a){return function(b,c){return a(function(a){return Ma(a,b,c)},c)}}function aa(a,b,c){function d(c,d,h){if(e+=c.length-d.length,!(h+d.length<e&&h+c.length<e)){var i=e<0?null:a.get(e);f(),f=b(i)||Function.noop,g=i}}var e=-1,f=Function.noop,g=null,h=$(a,d,c);return function(){f(),h()}}function ba(a){return function(b,c){return a(va(function(a){return ca(a,b,c)}),c)}}function ca(a,b,c){function d(c,d,f){return e+=c.length-d.length,1!==e?b():b(a.only())}var e=0;return $(a,d,c)}function da(a){return function(b,c){return a(va(function(a){return ea(a,b,c)}),c)}}function ea(a,b,c){function d(c,d,f){return e+=c.length-d.length,0===e?b():b(a.one())}var e=0;return $(a,d,c)}function fa(a){return function(b,c){return a(function(a){return a&&a.addRangeChangeListener?$(a,function(){return b(a)},c):b(a)},c)}}function ga(a){return function(b,c){return a(function(a){return a&&a.addMapChangeListener?ha(a,function(){return b(a)},c):b(a)},c)}}function ha(a,b,c){function d(a,c,d){var f=e.get(c)||Function.noop;e.delete(c),f(),f=b(a,c,d)||Function.noop,void 0===a?f():e.set(c,f)}if(a.addMapChangeListener){var e=new Ba;a.forEach(d);var f=a.addMapChangeListener(d,c.beforeChange);return function(){e.forEach(function(a){a()}),f()}}}function ia(a){return function(b,c){return a(function(a){return a?ja(a,b,c):b()},c)}}function ja(a,b,c){function d(a,b,c){var d,g;f.has(b)?null==a?(d=f.get(b),f.delete(b),g=e.indexOf(d),e.splice(g,1)):(d=f.get(b),d.set(1,a)):(d=[b,a],f.set(b,d),e.push(d))}var e=[],f=Ba(),g=b(e)||Function.noop,h=ha(a,d,c)||Function.noop;return function(){g(),h()}}function ka(a){return Ga(Na(a),la)}function la(a,b){return b.value?a(b.value[0]):a()}function ma(a){return Ga(Na(a),na)}function na(a,b){return b.value?a(b.value[1]):a()}function oa(a){return function(b,c){var d=new Ba,e=b(d)||Function.noop,f=a(function(a){if(d.clear(),a&&"object"==typeof a){if(a.addRangeChangeListener)return Oa(function(a){function b(a,b){b.forEach(function(a){d.delete(a[0])}),a.forEach(function(a){d.set(a[0],a[1])})}return $(a,b,c)},c.nest(a));if(a.addMapChangeListener)return ha(a,function(a,b){void 0===a?d.delete(b):d.set(b,a)},c);var b=Object.keys(a).map(function(b){return Ea(a,b,function(a){void 0===a?d.delete(b):d.set(b,a)},c)});return function(){wa(b)}}},c)||Function.noop;return function(){e(),f()}}}function pa(a){return function(b,c){return c.parent?a(b,c.parent):b()}}function qa(a,b,c){return function(d,e){return d=va(d),a(function(a){return d(b.call(c,a))},e)}}function ra(a,b,c){return function(d,e){return d=va(d),a(function(a){if(a&&a.every(Da.defined))return d(b.apply(c,a))},e)}}function sa(b,c){var d=a("./parse"),e=a("./compile-observer");return function(a,f){return a=va(a),c(function(c){if(null==c)return a();var g,h;try{g=d(c),h=e(g)}catch(b){return a()}return b(function(b){return h(a,f.nest(b))},f)},f)}}function ta(a,b){return function(c,d){return a(function(a){return null==a?c():b(function(a){return null==a?c():c(a)},d.nest(a))},d)}}function ua(a){return function(){var b=a.apply(this,arguments);return function(a,c){var d=[],e=b(function(a){function b(a,b,c){d.swap(c,b.length,a)}if(a){Pa(d,a);return a.addRangeChangeListener(b,null,c.beforeChange)}d.clear()},c),f=a(d)||Function.noop;return function(){e(),f()}}}}function va(a){var b;return function(c){if(c!==b){var d=a.apply(this,arguments);return b=c,d}}}function wa(a){a.forEach(function(a){a&&a()})}function xa(a){return function(){return a.apply(null,arguments)||Function.noop}}a("collections/shim")
+;var ya=a("collections/listen/property-changes");a("collections/listen/array-changes");var za=a("collections/sorted-array"),Aa=a("collections/sorted-set"),Ba=a("collections/map"),Ca=(a("collections/set"),a("collections/heap")),Da=(a("./scope"),a("./operators"));c.makeLiteralObserver=d,c.observeValue=e,c.observeParameters=f,c.makeElementObserver=g,c.makeComponentObserver=h,c.observeProperty=i;var Ea=i;c.makePropertyObserver=j,c.observeKey=k,c.observeGet=k;var Fa=k;c.makeGetObserver=l,c.makeHasObserver=m,c.makeObserversObserver=n,c.makeRecordObserver=o,c.makeObjectObserver=o,c.makeTupleObserver=p,c.makeArrayObserver=p,c.makeOperatorObserverMaker=q,c.makeMethodObserverMaker=r,c.makeNotObserver=s,c.makeAndObserver=t,c.makeOrObserver=u,c.makeConditionalObserver=v,c.makeDefinedObserver=w,c.makeDefaultObserver=x;var Ga=c.makeMapBlockObserver=ua(y),Ha=c.makeFilterBlockObserver=ua(z);c.makeSortedBlockObserver=A,c.makeSortedSetBlockObserver=E,c.makeReversedObserver=ua(F);var Ia=c.makeFlattenObserver=ua(G);c.makeConcatObserver=H,c.makeSomeBlockObserver=I,c.makeEveryBlockObserver=J,c.makeGroupBlockObserver=K,c.makeGroupMapBlockObserver=L,c.makeMaxBlockObserver=N,c.makeMinBlockObserver=O,c.makeMaxObserver=P,c.makeMinObserver=Q;var Ja=d("length");c.makeSumObserver=R(function(){var a=0;return function(b,c,d){return b=b.filter(S),c=c.filter(S),a+=b.sum()-c.sum()}}),c.makeAverageObserver=R(function(){var a=0,b=0;return function(c,d,e){return c=c.filter(S),d=d.filter(S),a+=c.sum()-d.sum(),b+=c.length-d.length,a/b}}),c.makeViewObserver=ua(T);var Ka=d(0);c.makeEnumerateObserver=ua(U),c.makeEnumerationObserver=c.makeEnumerateObserver,c.makeRangeObserver=V,c.makeStartsWithObserver=W,c.makeEndsWithObserver=X,c.makeContainsObserver=Y,c.makeJoinObserver=Z;var La=d("");c.observeRangeChange=$,c.makeLastObserver=_,c.observeLast=aa;var Ma=aa;c.makeOnlyObserver=ba,c.observeOnly=ca,c.makeOneObserver=da,c.observeOne=ea,c.makeRangeContentObserver=fa,c.makeMapContentObserver=ga,c.observeMapChange=ha;var Na=c.makeEntriesObserver=ua(ia);c.observeEntries=ja,c.makeKeysObserver=ka,c.observeEntryKey=la,c.makeValuesObserver=ma,c.observeEntryValue=na,c.makeToMapObserver=oa;var Oa=Ga(K(e,la),_(na));c.makeParentObserver=pa,c.makeConverterObserver=qa,c.makeComputerObserver=ra,c.makePathObserver=sa,c.makeExpressionObserver=sa,c.makeWithObserver=ta,c.makeToArrayObserver=ua(Function.identity),c.makeAsArrayObserver=c.makeToArrayObserver;var Pa=a("./merge").merge;c.makeUniq=va,c.cancelEach=wa,c.autoCancelPrevious=xa},{"./compile-observer":33,"./merge":38,"./operators":64,"./parse":65,"./scope":66,"collections/heap":45,"collections/listen/array-changes":47,"collections/listen/property-changes":49,"collections/map":51,"collections/set":53,"collections/shim":58,"collections/sorted-array":59,"collections/sorted-set":60}],64:[function(a,b,c){a("collections/shim-object"),a("collections/shim-regexp");var d=a("collections/map"),e=a("collections/set");c.toNumber=function(a){return+a},c.toString=function(a){return null==a?a:"string"==typeof a||"number"==typeof a?""+a:null},c.toArray=Array.from,c.toMap=d,c.toSet=e,c.not=function(a){return!a},c.neg=function(a){return-a},c.pow=function(a,b){return Math.pow(a,b)},c.root=function(a,b){return Math.pow(a,1/b)},c.log=function(a,b){return Math.log(a)/Math.log(b)},c.mul=function(a,b){return a*b},c.div=function(a,b){return a/b},c.mod=function(a,b){return(a%b+b)%b},c.rem=function(a,b){return a%b},c.add=function(a,b){return a+b},c.sub=function(a,b){return a-b},c.ceil=function(a){return Math.ceil(a)},c.floor=function(a){return Math.floor(a)},c.round=function(a){return Math.round(a)},c.lt=function(a,b){return Object.compare(a,b)<0},c.gt=function(a,b){return Object.compare(a,b)>0},c.le=function(a,b){return Object.compare(a,b)<=0},c.ge=function(a,b){return Object.compare(a,b)>=0},c.equals=Object.equals,c.compare=Object.compare,c.and=function(a,b){return a&&b},c.or=function(a,b){return a||b},c.defined=function(a){return null!=a},c.startsWith=function(a,b){return new RegExp("^"+RegExp.escape(b)).test(a)},c.endsWith=function(a,b){return new RegExp(RegExp.escape(b)+"$").test(a)},c.contains=function(a,b){return new RegExp(RegExp.escape(b)).test(a)},c.join=function(a,b){return a.join(b||"")},c.split=function(a,b){return a.split(b||"")},c.range=function(a){for(var b=[],c=0;c<a;c++)b.push(c);return b},c.last=function(a){return a.get(a.length-1)}},{"collections/map":51,"collections/set":53,"collections/shim-object":56,"collections/shim-regexp":57}],65:[function(a,b,c){function d(a,b){if(Array.isArray(a))return{type:"tuple",args:a.map(function(a){return d(a,b)})};try{return e.parse(a,b||Object.empty)}catch(a){throw a.message=a.message.replace(/[\s\.]+$/,"")+"  on line "+a.line+" column "+a.column,a}}a("collections/shim");var e=a("./grammar");b.exports=d},{"./grammar":36,"collections/shim":58}],66:[function(a,b,c){function d(a){this.parent=null,this.value=a}b.exports=d,d.prototype.nest=function(a){var b=Object.create(this);return b.value=a,b.parent=this,b}},{}],67:[function(a,b,c){"use strict";function d(a,b){return d.semantics.stringify(a,b)}function e(a){return function(b,c,d){var e=a+"{"+d(b.args[1],c)+"}";return"value"===b.args[0].type?e:d(b.args[0],c)+"."+e}}var f=(a("./parse"),a("./language").precedence),g=a("./language").operatorTypes;a("./language").operatorTokens;b.exports=d,d.semantics={makeBlockStringifier:e,stringify:function(a,b,c){function d(a){var c=g(a,b);return c?c:"this"}var e,g=this.stringify.bind(this),h=this.stringifiers;if(h[a.type])e=h[a.type](a,b,g);else if(a.inline)e="&"+a.type+"("+a.args.map(d).join(", ")+")";else{var i;1===a.args.length&&"mapBlock"===a.args[0].type?(i=a.type+"{"+g(a.args[0].args[1],b)+"}",a=a.args[0]):i=a.type+"("+a.args.slice(1).map(d).join(", ")+")",e="value"===a.args[0].type?i:g(a.args[0],b)+"."+i}return!c||c.type===a.type&&"if"!==c.type||f.get(c.type).has(a.type)?e:"("+e+")"},stringifiers:{value:function(a,b,c){return""},literal:function(a,b,c){return"string"==typeof a.value?"'"+a.value.replace("'","\\'")+"'":""+a.value},parameters:function(a,b,c){return"$"},record:function(a,b,c){return"{"+Object.map(a.args,function(a,d){var e;return e="value"===a.type?"this":c(a,b),d+": "+e}).join(", ")+"}"},tuple:function(a,b,c){return"["+Object.map(a.args,function(a){return"value"===a.type?"this":c(a)}).join(", ")+"]"},component:function(a,b){var c;return b&&b.components&&a.component?b.components.getObjectLabel?c=b.components.getObjectLabel(a.component):b.components.getLabelForObject&&(c=b.components.getLabelForObject(a.component)):c=a.label,"@"+c},element:function(a){return"#"+a.id},mapBlock:e("map"),filterBlock:e("filter"),someBlock:e("some"),everyBlock:e("every"),sortedBlock:e("sorted"),sortedSetBlock:e("sortedSet"),groupBlock:e("group"),groupMapBlock:e("groupMap"),minBlock:e("min"),maxBlock:e("max"),property:function(a,b,c){return"value"===a.args[0].type?"string"==typeof a.args[1].value?a.args[1].value:"literal"===a.args[1].type?"."+a.args[1].value:"this["+c(a.args[1],b)+"]":"parameters"===a.args[0].type?"$"+a.args[1].value:"literal"===a.args[1].type&&/^[\w\d_]+$/.test(a.args[1].value)?c(a.args[0],b,{type:"scope"})+"."+a.args[1].value:c(a.args[0],{type:"scope"},b)+"["+c(a.args[1],b)+"]"},with:function(a,b,c){var d=c(a.args[1],b,a);return c(a.args[0],b)+"."+d},not:function(a,b,c){return"equals"===a.args[0].type?c(a.args[0].args[0],b,{type:"equals"})+" != "+c(a.args[0].args[1],b,{type:"equals"}):"!"+c(a.args[0],b,a)},neg:function(a,b,c){return"-"+c(a.args[0],b,a)},toNumber:function(a,b,c){return"+"+c(a.args[0],b,a)},parent:function(a,b,c){return"^"+c(a.args[0],b,a)},if:function(a,b,c){return c(a.args[0],b,a)+" ? "+c(a.args[1],b)+" : "+c(a.args[2],b)},event:function(a,b,c){return a.when+" "+a.event+" -> "+c(a.listener,b)},binding:function(a,b,c,d){var e=d(b.args[0],c)+" "+a+" "+d(b.args[1],c),f="",g=b.descriptor;if(g)for(var h in g)f+=", "+h+": "+d(g[h],c);return e+f},bind:function(a,b,c){return this.binding("<-",a,b,c)},bind2:function(a,b,c){return this.binding("<->",a,b,c)},assign:function(a,b,c){return c(a.args[0],b)+": "+c(a.args[1],b)},block:function(a,b,c){var d="@"+a.label;return a.connection&&("prototype"===a.connection?d+=" < ":"object"===a.connection&&(d+=" : "),d+=c({type:"literal",value:a.module}),a.exports&&"value"!==a.exports.type&&(d+=" "+c(a.exports,b))),d+" {\n"+a.statements.map(function(a){return"    "+c(a,b)+";\n"}).join("")+"}\n"},sheet:function(a,b,c){return"\n"+a.blocks.map(function(a){return c(a,b)}).join("\n")+"\n"}}},g.forEach(function(a,b){d.semantics.stringifiers[b]=function(b,c,d){return b.args.map(function(a){return d(a,c,b)}).join(" "+a+" ").trim()}})},{"./language":37,"./parse":65}],68:[function(a,b,c){},{}],69:[function(a,b,c){(function(b){"use strict";function d(){return f.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function e(a,b){if(d()<b)throw new RangeError("Invalid typed array length");return f.TYPED_ARRAY_SUPPORT?(a=new Uint8Array(b),a.__proto__=f.prototype):(null===a&&(a=new f(b)),a.length=b),a}function f(a,b,c){if(!(f.TYPED_ARRAY_SUPPORT||this instanceof f))return new f(a,b,c);if("number"==typeof a){if("string"==typeof b)throw new Error("If encoding is specified then the first argument must be a string");return j(this,a)}return g(this,a,b,c)}function g(a,b,c,d){if("number"==typeof b)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&b instanceof ArrayBuffer?m(a,b,c,d):"string"==typeof b?k(a,b,c):n(a,b)}function h(a){if("number"!=typeof a)throw new TypeError('"size" argument must be a number');if(a<0)throw new RangeError('"size" argument must not be negative')}function i(a,b,c,d){return h(b),b<=0?e(a,b):void 0!==c?"string"==typeof d?e(a,b).fill(c,d):e(a,b).fill(c):e(a,b)}function j(a,b){if(h(b),a=e(a,b<0?0:0|o(b)),!f.TYPED_ARRAY_SUPPORT)for(var c=0;c<b;++c)a[c]=0;return a}function k(a,b,c){if("string"==typeof c&&""!==c||(c="utf8"),!f.isEncoding(c))throw new TypeError('"encoding" must be a valid string encoding');var d=0|q(b,c);a=e(a,d);var g=a.write(b,c);return g!==d&&(a=a.slice(0,g)),a}function l(a,b){var c=b.length<0?0:0|o(b.length);a=e(a,c);for(var d=0;d<c;d+=1)a[d]=255&b[d];return a}function m(a,b,c,d){if(b.byteLength,c<0||b.byteLength<c)throw new RangeError("'offset' is out of bounds");if(b.byteLength<c+(d||0))throw new RangeError("'length' is out of bounds");return b=void 0===c&&void 0===d?new Uint8Array(b):void 0===d?new Uint8Array(b,c):new Uint8Array(b,c,d),f.TYPED_ARRAY_SUPPORT?(a=b,a.__proto__=f.prototype):a=l(a,b),a}function n(a,b){if(f.isBuffer(b)){var c=0|o(b.length);return a=e(a,c),0===a.length?a:(b.copy(a,0,0,c),a)}if(b){if("undefined"!=typeof ArrayBuffer&&b.buffer instanceof ArrayBuffer||"length"in b)return"number"!=typeof b.length||X(b.length)?e(a,0):l(a,b);if("Buffer"===b.type&&$(b.data))return l(a,b.data)}throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}function o(a){if(a>=d())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+d().toString(16)+" bytes");return 0|a}function p(a){return+a!=a&&(a=0),f.alloc(+a)}function q(a,b){if(f.isBuffer(a))return a.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(a)||a instanceof ArrayBuffer))return a.byteLength;"string"!=typeof a&&(a=""+a);var c=a.length;if(0===c)return 0;for(var d=!1;;)switch(b){case"ascii":case"latin1":case"binary":return c;case"utf8":case"utf-8":case void 0:return S(a).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*c;case"hex":return c>>>1;case"base64":return V(a).length;default:if(d)return S(a).length;b=(""+b).toLowerCase(),d=!0}}function r(a,b,c){var d=!1;if((void 0===b||b<0)&&(b=0),b>this.length)return"";if((void 0===c||c>this.length)&&(c=this.length),c<=0)return"";if(c>>>=0,b>>>=0,c<=b)return"";for(a||(a="utf8");;)switch(a){case"hex":return G(this,b,c);case"utf8":case"utf-8":return C(this,b,c);case"ascii":return E(this,b,c);case"latin1":case"binary":return F(this,b,c);case"base64":return B(this,b,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return H(this,b,c);default:if(d)throw new TypeError("Unknown encoding: "+a);a=(a+"").toLowerCase(),d=!0}}function s(a,b,c){var d=a[b];a[b]=a[c],a[c]=d}function t(a,b,c,d,e){if(0===a.length)return-1;if("string"==typeof c?(d=c,c=0):c>2147483647?c=2147483647:c<-2147483648&&(c=-2147483648),c=+c,isNaN(c)&&(c=e?0:a.length-1),c<0&&(c=a.length+c),c>=a.length){if(e)return-1;c=a.length-1}else if(c<0){if(!e)return-1;c=0}if("string"==typeof b&&(b=f.from(b,d)),f.isBuffer(b))return 0===b.length?-1:u(a,b,c,d,e);if("number"==typeof b)return b&=255,f.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?e?Uint8Array.prototype.indexOf.call(a,b,c):Uint8Array.prototype.lastIndexOf.call(a,b,c):u(a,[b],c,d,e);throw new TypeError("val must be string, number or Buffer")}function u(a,b,c,d,e){function f(a,b){return 1===g?a[b]:a.readUInt16BE(b*g)}var g=1,h=a.length,i=b.length;if(void 0!==d&&("ucs2"===(d=String(d).toLowerCase())||"ucs-2"===d||"utf16le"===d||"utf-16le"===d)){if(a.length<2||b.length<2)return-1;g=2,h/=2,i/=2,c/=2}var j;if(e){var k=-1;for(j=c;j<h;j++)if(f(a,j)===f(b,k===-1?0:j-k)){if(k===-1&&(k=j),j-k+1===i)return k*g}else k!==-1&&(j-=j-k),k=-1}else for(c+i>h&&(c=h-i),j=c;j>=0;j--){for(var l=!0,m=0;m<i;m++)if(f(a,j+m)!==f(b,m)){l=!1;break}if(l)return j}return-1}function v(a,b,c,d){c=Number(c)||0;var e=a.length-c;d?(d=Number(d))>e&&(d=e):d=e;var f=b.length;if(f%2!=0)throw new TypeError("Invalid hex string");d>f/2&&(d=f/2);for(var g=0;g<d;++g){var h=parseInt(b.substr(2*g,2),16);if(isNaN(h))return g;a[c+g]=h}return g}function w(a,b,c,d){return W(S(b,a.length-c),a,c,d)}function x(a,b,c,d){return W(T(b),a,c,d)}function y(a,b,c,d){return x(a,b,c,d)}function z(a,b,c,d){return W(V(b),a,c,d)}function A(a,b,c,d){return W(U(b,a.length-c),a,c,d)}function B(a,b,c){return 0===b&&c===a.length?Y.fromByteArray(a):Y.fromByteArray(a.slice(b,c))}function C(a,b,c){c=Math.min(a.length,c);for(var d=[],e=b;e<c;){var f=a[e],g=null,h=f>239?4:f>223?3:f>191?2:1;if(e+h<=c){var i,j,k,l;switch(h){case 1:f<128&&(g=f);break;case 2:i=a[e+1],128==(192&i)&&(l=(31&f)<<6|63&i)>127&&(g=l);break;case 3:i=a[e+1],j=a[e+2],128==(192&i)&&128==(192&j)&&(l=(15&f)<<12|(63&i)<<6|63&j)>2047&&(l<55296||l>57343)&&(g=l);break;case 4:i=a[e+1],j=a[e+2],k=a[e+3],128==(192&i)&&128==(192&j)&&128==(192&k)&&(l=(15&f)<<18|(63&i)<<12|(63&j)<<6|63&k)>65535&&l<1114112&&(g=l)}}null===g?(g=65533,h=1):g>65535&&(g-=65536,d.push(g>>>10&1023|55296),g=56320|1023&g),d.push(g),e+=h}return D(d)}function D(a){var b=a.length;if(b<=_)return String.fromCharCode.apply(String,a);for(var c="",d=0;d<b;)c+=String.fromCharCode.apply(String,a.slice(d,d+=_));return c}function E(a,b,c){var d="";c=Math.min(a.length,c);for(var e=b;e<c;++e)d+=String.fromCharCode(127&a[e]);return d}function F(a,b,c){var d="";c=Math.min(a.length,c);for(var e=b;e<c;++e)d+=String.fromCharCode(a[e]);return d}function G(a,b,c){var d=a.length;(!b||b<0)&&(b=0),(!c||c<0||c>d)&&(c=d);for(var e="",f=b;f<c;++f)e+=R(a[f]);return e}function H(a,b,c){for(var d=a.slice(b,c),e="",f=0;f<d.length;f+=2)e+=String.fromCharCode(d[f]+256*d[f+1]);return e}function I(a,b,c){if(a%1!=0||a<0)throw new RangeError("offset is not uint");if(a+b>c)throw new RangeError("Trying to access beyond buffer length")}function J(a,b,c,d,e,g){if(!f.isBuffer(a))throw new TypeError('"buffer" argument must be a Buffer instance');if(b>e||b<g)throw new RangeError('"value" argument is out of bounds');if(c+d>a.length)throw new RangeError("Index out of range")}function K(a,b,c,d){b<0&&(b=65535+b+1);for(var e=0,f=Math.min(a.length-c,2);e<f;++e)a[c+e]=(b&255<<8*(d?e:1-e))>>>8*(d?e:1-e)}function L(a,b,c,d){b<0&&(b=4294967295+b+1);for(var e=0,f=Math.min(a.length-c,4);e<f;++e)a[c+e]=b>>>8*(d?e:3-e)&255}function M(a,b,c,d,e,f){if(c+d>a.length)throw new RangeError("Index out of range");if(c<0)throw new RangeError("Index out of range")}function N(a,b,c,d,e){return e||M(a,b,c,4,3.4028234663852886e38,-3.4028234663852886e38),Z.write(a,b,c,d,23,4),c+4}function O(a,b,c,d,e){return e||M(a,b,c,8,1.7976931348623157e308,-1.7976931348623157e308),Z.write(a,b,c,d,52,8),c+8}function P(a){if(a=Q(a).replace(aa,""),a.length<2)return"";for(;a.length%4!=0;)a+="=";return a}function Q(a){return a.trim?a.trim():a.replace(/^\s+|\s+$/g,"")}function R(a){return a<16?"0"+a.toString(16):a.toString(16)}function S(a,b){b=b||1/0;for(var c,d=a.length,e=null,f=[],g=0;g<d;++g){if((c=a.charCodeAt(g))>55295&&c<57344){if(!e){if(c>56319){(b-=3)>-1&&f.push(239,191,189);continue}if(g+1===d){(b-=3)>-1&&f.push(239,191,189);continue}e=c;continue}if(c<56320){(b-=3)>-1&&f.push(239,191,189),e=c;continue}c=65536+(e-55296<<10|c-56320)}else e&&(b-=3)>-1&&f.push(239,191,189);if(e=null,c<128){if((b-=1)<0)break;f.push(c)}else if(c<2048){if((b-=2)<0)break;f.push(c>>6|192,63&c|128)}else if(c<65536){if((b-=3)<0)break;f.push(c>>12|224,c>>6&63|128,63&c|128)}else{if(!(c<1114112))throw new Error("Invalid code point");if((b-=4)<0)break;f.push(c>>18|240,c>>12&63|128,c>>6&63|128,63&c|128)}}return f}function T(a){for(var b=[],c=0;c<a.length;++c)b.push(255&a.charCodeAt(c));return b}function U(a,b){for(var c,d,e,f=[],g=0;g<a.length&&!((b-=2)<0);++g)c=a.charCodeAt(g),d=c>>8,e=c%256,f.push(e),f.push(d);return f}function V(a){return Y.toByteArray(P(a))}function W(a,b,c,d){for(var e=0;e<d&&!(e+c>=b.length||e>=a.length);++e)b[e+c]=a[e];return e}function X(a){return a!==a}var Y=a("base64-js"),Z=a("ieee754"),$=a("isarray");c.Buffer=f,c.SlowBuffer=p,c.INSPECT_MAX_BYTES=50,f.TYPED_ARRAY_SUPPORT=void 0!==b.TYPED_ARRAY_SUPPORT?b.TYPED_ARRAY_SUPPORT:function(){try{var a=new Uint8Array(1);return a.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===a.foo()&&"function"==typeof a.subarray&&0===a.subarray(1,1).byteLength}catch(a){return!1}}(),c.kMaxLength=d(),f.poolSize=8192,f._augment=function(a){return a.__proto__=f.prototype,a},f.from=function(a,b,c){return g(null,a,b,c)},f.TYPED_ARRAY_SUPPORT&&(f.prototype.__proto__=Uint8Array.prototype,f.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&f[Symbol.species]===f&&Object.defineProperty(f,Symbol.species,{value:null,configurable:!0})),f.alloc=function(a,b,c){return i(null,a,b,c)},f.allocUnsafe=function(a){return j(null,a)},f.allocUnsafeSlow=function(a){return j(null,a)},f.isBuffer=function(a){return!(null==a||!a._isBuffer)},f.compare=function(a,b){if(!f.isBuffer(a)||!f.isBuffer(b))throw new TypeError("Arguments must be Buffers");if(a===b)return 0;for(var c=a.length,d=b.length,e=0,g=Math.min(c,d);e<g;++e)if(a[e]!==b[e]){c=a[e],d=b[e];break}return c<d?-1:d<c?1:0},f.isEncoding=function(a){switch(String(a).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},f.concat=function(a,b){if(!$(a))throw new TypeError('"list" argument must be an Array of Buffers');if(0===a.length)return f.alloc(0);var c;if(void 0===b)for(b=0,c=0;c<a.length;++c)b+=a[c].length;var d=f.allocUnsafe(b),e=0;for(c=0;c<a.length;++c){var g=a[c];if(!f.isBuffer(g))throw new TypeError('"list" argument must be an Array of Buffers');g.copy(d,e),e+=g.length}return d},f.byteLength=q,f.prototype._isBuffer=!0,f.prototype.swap16=function(){var a=this.length;if(a%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var b=0;b<a;b+=2)s(this,b,b+1);return this},f.prototype.swap32=function(){var a=this.length;if(a%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var b=0;b<a;b+=4)s(this,b,b+3),s(this,b+1,b+2);return this},f.prototype.swap64=function(){var a=this.length;if(a%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var b=0;b<a;b+=8)s(this,b,b+7),s(this,b+1,b+6),s(this,b+2,b+5),s(this,b+3,b+4);return this},f.prototype.toString=function(){var a=0|this.length;return 0===a?"":0===arguments.length?C(this,0,a):r.apply(this,arguments)},f.prototype.equals=function(a){if(!f.isBuffer(a))throw new TypeError("Argument must be a Buffer");return this===a||0===f.compare(this,a)},f.prototype.inspect=function(){var a="",b=c.INSPECT_MAX_BYTES;return this.length>0&&(a=this.toString("hex",0,b).match(/.{2}/g).join(" "),this.length>b&&(a+=" ... ")),"<Buffer "+a+">"},f.prototype.compare=function(a,b,c,d,e){if(!f.isBuffer(a))throw new TypeError("Argument must be a Buffer");if(void 0===b&&(b=0),void 0===c&&(c=a?a.length:0),void 0===d&&(d=0),void 0===e&&(e=this.length),b<0||c>a.length||d<0||e>this.length)throw new RangeError("out of range index");if(d>=e&&b>=c)return 0;if(d>=e)return-1;if(b>=c)return 1;if(b>>>=0,c>>>=0,d>>>=0,e>>>=0,this===a)return 0;for(var g=e-d,h=c-b,i=Math.min(g,h),j=this.slice(d,e),k=a.slice(b,c),l=0;l<i;++l)if(j[l]!==k[l]){g=j[l],h=k[l];break}return g<h?-1:h<g?1:0},f.prototype.includes=function(a,b,c){return this.indexOf(a,b,c)!==-1},f.prototype.indexOf=function(a,b,c){return t(this,a,b,c,!0)},f.prototype.lastIndexOf=function(a,b,c){return t(this,a,b,c,!1)},f.prototype.write=function(a,b,c,d){if(void 0===b)d="utf8",c=this.length,b=0;else if(void 0===c&&"string"==typeof b)d=b,c=this.length,b=0;else{if(!isFinite(b))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");b|=0,isFinite(c)?(c|=0,void 0===d&&(d="utf8")):(d=c,c=void 0)}var e=this.length-b;if((void 0===c||c>e)&&(c=e),a.length>0&&(c<0||b<0)||b>this.length)throw new RangeError("Attempt to write outside buffer bounds");d||(d="utf8");for(var f=!1;;)switch(d){case"hex":return v(this,a,b,c);case"utf8":case"utf-8":return w(this,a,b,c);case"ascii":return x(this,a,b,c);case"latin1":case"binary":return y(this,a,b,c);case"base64":return z(this,a,b,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return A(this,a,b,c);default:if(f)throw new TypeError("Unknown encoding: "+d);d=(""+d).toLowerCase(),f=!0}},f.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var _=4096;f.prototype.slice=function(a,b){var c=this.length;a=~~a,b=void 0===b?c:~~b,a<0?(a+=c)<0&&(a=0):a>c&&(a=c),b<0?(b+=c)<0&&(b=0):b>c&&(b=c),b<a&&(b=a);var d;if(f.TYPED_ARRAY_SUPPORT)d=this.subarray(a,b),d.__proto__=f.prototype;else{var e=b-a;d=new f(e,void 0);for(var g=0;g<e;++g)d[g]=this[g+a]}return d},f.prototype.readUIntLE=function(a,b,c){a|=0,b|=0,c||I(a,b,this.length);for(var d=this[a],e=1,f=0;++f<b&&(e*=256);)d+=this[a+f]*e;return d},f.prototype.readUIntBE=function(a,b,c){a|=0,b|=0,c||I(a,b,this.length);for(var d=this[a+--b],e=1;b>0&&(e*=256);)d+=this[a+--b]*e;return d},f.prototype.readUInt8=function(a,b){return b||I(a,1,this.length),this[a]},f.prototype.readUInt16LE=function(a,b){return b||I(a,2,this.length),this[a]|this[a+1]<<8},f.prototype.readUInt16BE=function(a,b){return b||I(a,2,this.length),this[a]<<8|this[a+1]},f.prototype.readUInt32LE=function(a,b){return b||I(a,4,this.length),(this[a]|this[a+1]<<8|this[a+2]<<16)+16777216*this[a+3]},f.prototype.readUInt32BE=function(a,b){return b||I(a,4,this.length),16777216*this[a]+(this[a+1]<<16|this[a+2]<<8|this[a+3])},f.prototype.readIntLE=function(a,b,c){a|=0,b|=0,c||I(a,b,this.length);for(var d=this[a],e=1,f=0;++f<b&&(e*=256);)d+=this[a+f]*e;return e*=128,d>=e&&(d-=Math.pow(2,8*b)),d},f.prototype.readIntBE=function(a,b,c){a|=0,b|=0,c||I(a,b,this.length);for(var d=b,e=1,f=this[a+--d];d>0&&(e*=256);)f+=this[a+--d]*e;return e*=128,f>=e&&(f-=Math.pow(2,8*b)),f},f.prototype.readInt8=function(a,b){return b||I(a,1,this.length),128&this[a]?(255-this[a]+1)*-1:this[a]},f.prototype.readInt16LE=function(a,b){b||I(a,2,this.length);var c=this[a]|this[a+1]<<8;return 32768&c?4294901760|c:c},f.prototype.readInt16BE=function(a,b){b||I(a,2,this.length);var c=this[a+1]|this[a]<<8;return 32768&c?4294901760|c:c},f.prototype.readInt32LE=function(a,b){return b||I(a,4,this.length),this[a]|this[a+1]<<8|this[a+2]<<16|this[a+3]<<24},f.prototype.readInt32BE=function(a,b){return b||I(a,4,this.length),this[a]<<24|this[a+1]<<16|this[a+2]<<8|this[a+3]},f.prototype.readFloatLE=function(a,b){return b||I(a,4,this.length),Z.read(this,a,!0,23,4)},f.prototype.readFloatBE=function(a,b){return b||I(a,4,this.length),Z.read(this,a,!1,23,4)},f.prototype.readDoubleLE=function(a,b){return b||I(a,8,this.length),Z.read(this,a,!0,52,8)},f.prototype.readDoubleBE=function(a,b){return b||I(a,8,this.length),Z.read(this,a,!1,52,8)},f.prototype.writeUIntLE=function(a,b,c,d){if(a=+a,b|=0,c|=0,!d){J(this,a,b,c,Math.pow(2,8*c)-1,0)}var e=1,f=0;for(this[b]=255&a;++f<c&&(e*=256);)this[b+f]=a/e&255;return b+c},f.prototype.writeUIntBE=function(a,b,c,d){if(a=+a,b|=0,c|=0,!d){J(this,a,b,c,Math.pow(2,8*c)-1,0)}var e=c-1,f=1;for(this[b+e]=255&a;--e>=0&&(f*=256);)this[b+e]=a/f&255;return b+c},f.prototype.writeUInt8=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,1,255,0),f.TYPED_ARRAY_SUPPORT||(a=Math.floor(a)),this[b]=255&a,b+1},f.prototype.writeUInt16LE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,2,65535,0),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8):K(this,a,b,!0),b+2},f.prototype.writeUInt16BE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,2,65535,0),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=255&a):K(this,a,b,!1),b+2},f.prototype.writeUInt32LE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,4,4294967295,0),f.TYPED_ARRAY_SUPPORT?(this[b+3]=a>>>24,this[b+2]=a>>>16,this[b+1]=a>>>8,this[b]=255&a):L(this,a,b,!0),b+4},f.prototype.writeUInt32BE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,4,4294967295,0),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+2]=a>>>8,this[b+3]=255&a):L(this,a,b,!1),b+4},f.prototype.writeIntLE=function(a,b,c,d){if(a=+a,b|=0,!d){var e=Math.pow(2,8*c-1);J(this,a,b,c,e-1,-e)}var f=0,g=1,h=0;for(this[b]=255&a;++f<c&&(g*=256);)a<0&&0===h&&0!==this[b+f-1]&&(h=1),this[b+f]=(a/g>>0)-h&255;return b+c},f.prototype.writeIntBE=function(a,b,c,d){if(a=+a,b|=0,!d){var e=Math.pow(2,8*c-1);J(this,a,b,c,e-1,-e)}var f=c-1,g=1,h=0;for(this[b+f]=255&a;--f>=0&&(g*=256);)a<0&&0===h&&0!==this[b+f+1]&&(h=1),this[b+f]=(a/g>>0)-h&255;return b+c},f.prototype.writeInt8=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,1,127,-128),f.TYPED_ARRAY_SUPPORT||(a=Math.floor(a)),a<0&&(a=255+a+1),this[b]=255&a,b+1},f.prototype.writeInt16LE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,2,32767,-32768),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8):K(this,a,b,!0),b+2},f.prototype.writeInt16BE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,2,32767,-32768),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=255&a):K(this,a,b,!1),b+2},f.prototype.writeInt32LE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,4,2147483647,-2147483648),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8,this[b+2]=a>>>16,this[b+3]=a>>>24):L(this,a,b,!0),b+4},f.prototype.writeInt32BE=function(a,b,c){return a=+a,b|=0,c||J(this,a,b,4,2147483647,-2147483648),a<0&&(a=4294967295+a+1),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+2]=a>>>8,this[b+3]=255&a):L(this,a,b,!1),b+4},f.prototype.writeFloatLE=function(a,b,c){return N(this,a,b,!0,c)},f.prototype.writeFloatBE=function(a,b,c){return N(this,a,b,!1,c)},f.prototype.writeDoubleLE=function(a,b,c){return O(this,a,b,!0,c)},f.prototype.writeDoubleBE=function(a,b,c){return O(this,a,b,!1,c)},f.prototype.copy=function(a,b,c,d){if(c||(c=0),d||0===d||(d=this.length),b>=a.length&&(b=a.length),b||(b=0),d>0&&d<c&&(d=c),d===c)return 0;if(0===a.length||0===this.length)return 0;if(b<0)throw new RangeError("targetStart out of bounds");if(c<0||c>=this.length)throw new RangeError("sourceStart out of bounds");if(d<0)throw new RangeError("sourceEnd out of bounds");d>this.length&&(d=this.length),a.length-b<d-c&&(d=a.length-b+c);var e,g=d-c;if(this===a&&c<b&&b<d)for(e=g-1;e>=0;--e)a[e+b]=this[e+c];else if(g<1e3||!f.TYPED_ARRAY_SUPPORT)for(e=0;e<g;++e)a[e+b]=this[e+c];else Uint8Array.prototype.set.call(a,this.subarray(c,c+g),b);return g},f.prototype.fill=function(a,b,c,d){if("string"==typeof a){if("string"==typeof b?(d=b,b=0,c=this.length):"string"==typeof c&&(d=c,c=this.length),1===a.length){var e=a.charCodeAt(0);e<256&&(a=e)}if(void 0!==d&&"string"!=typeof d)throw new TypeError("encoding must be a string");if("string"==typeof d&&!f.isEncoding(d))throw new TypeError("Unknown encoding: "+d)}else"number"==typeof a&&(a&=255);if(b<0||this.length<b||this.length<c)throw new RangeError("Out of range index");if(c<=b)return this;b>>>=0,c=void 0===c?this.length:c>>>0,a||(a=0);var g;if("number"==typeof a)for(g=b;g<c;++g)this[g]=a;else{var h=f.isBuffer(a)?a:S(new f(a,d).toString()),i=h.length;for(g=0;g<c-b;++g)this[g+b]=h[g%i]}return this};var aa=/[^+\/0-9A-Za-z-_]/g}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"base64-js":70,ieee754:71,isarray:72}],70:[function(a,b,c){"use strict";function d(a){var b=a.length;if(b%4>0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===a[b-2]?2:"="===a[b-1]?1:0}function e(a){return 3*a.length/4-d(a)}function f(a){var b,c,e,f,g,h,i=a.length;g=d(a),h=new l(3*i/4-g),e=g>0?i-4:i;var j=0;for(b=0,c=0;b<e;b+=4,c+=3)f=k[a.charCodeAt(b)]<<18|k[a.charCodeAt(b+1)]<<12|k[a.charCodeAt(b+2)]<<6|k[a.charCodeAt(b+3)],h[j++]=f>>16&255,h[j++]=f>>8&255,h[j++]=255&f;return 2===g?(f=k[a.charCodeAt(b)]<<2|k[a.charCodeAt(b+1)]>>4,h[j++]=255&f):1===g&&(f=k[a.charCodeAt(b)]<<10|k[a.charCodeAt(b+1)]<<4|k[a.charCodeAt(b+2)]>>2,h[j++]=f>>8&255,h[j++]=255&f),h}function g(a){return j[a>>18&63]+j[a>>12&63]+j[a>>6&63]+j[63&a]}function h(a,b,c){for(var d,e=[],f=b;f<c;f+=3)d=(a[f]<<16)+(a[f+1]<<8)+a[f+2],e.push(g(d));return e.join("")}function i(a){for(var b,c=a.length,d=c%3,e="",f=[],g=0,i=c-d;g<i;g+=16383)f.push(h(a,g,g+16383>i?i:g+16383));return 1===d?(b=a[c-1],e+=j[b>>2],e+=j[b<<4&63],e+="=="):2===d&&(b=(a[c-2]<<8)+a[c-1],e+=j[b>>10],e+=j[b>>4&63],e+=j[b<<2&63],e+="="),f.push(e),f.join("")}c.byteLength=e,c.toByteArray=f,c.fromByteArray=i;for(var j=[],k=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,m="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",n=0,o=m.length;n<o;++n)j[n]=m[n],k[m.charCodeAt(n)]=n;k["-".charCodeAt(0)]=62,k["_".charCodeAt(0)]=63},{}],71:[function(a,b,c){c.read=function(a,b,c,d,e){var f,g,h=8*e-d-1,i=(1<<h)-1,j=i>>1,k=-7,l=c?e-1:0,m=c?-1:1,n=a[b+l];for(l+=m,f=n&(1<<-k)-1,n>>=-k,k+=h;k>0;f=256*f+a[b+l],l+=m,k-=8);for(g=f&(1<<-k)-1,f>>=-k,k+=d;k>0;g=256*g+a[b+l],l+=m,k-=8);if(0===f)f=1-j;else{if(f===i)return g?NaN:1/0*(n?-1:1);g+=Math.pow(2,d),f-=j}return(n?-1:1)*g*Math.pow(2,f-d)},c.write=function(a,b,c,d,e,f){var g,h,i,j=8*f-e-1,k=(1<<j)-1,l=k>>1,m=23===e?Math.pow(2,-24)-Math.pow(2,-77):0,n=d?0:f-1,o=d?1:-1,p=b<0||0===b&&1/b<0?1:0;for(b=Math.abs(b),isNaN(b)||b===1/0?(h=isNaN(b)?1:0,g=k):(g=Math.floor(Math.log(b)/Math.LN2),b*(i=Math.pow(2,-g))<1&&(g--,i*=2),b+=g+l>=1?m/i:m*Math.pow(2,1-l),b*i>=2&&(g++,i/=2),g+l>=k?(h=0,g=k):g+l>=1?(h=(b*i-1)*Math.pow(2,e),g+=l):(h=b*Math.pow(2,l-1)*Math.pow(2,e),g=0));e>=8;a[c+n]=255&h,n+=o,h/=256,e-=8);for(g=g<<e|h,j+=e;j>0;a[c+n]=255&g,n+=o,g/=256,j-=8);a[c+n-o]|=128*p}},{}],72:[function(a,b,c){var d={}.toString;b.exports=Array.isArray||function(a){return"[object Array]"==d.call(a)}},{}],73:[function(a,b,c){function d(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function e(a){return"function"==typeof a}function f(a){return"number"==typeof a}function g(a){return"object"==typeof a&&null!==a}function h(a){return void 0===a}b.exports=d,d.EventEmitter=d,d.prototype._events=void 0,d.prototype._maxListeners=void 0,d.defaultMaxListeners=10,d.prototype.setMaxListeners=function(a){if(!f(a)||a<0||isNaN(a))throw TypeError("n must be a positive number");return this._maxListeners=a,this},d.prototype.emit=function(a){var b,c,d,f,i,j;if(this._events||(this._events={}),"error"===a&&(!this._events.error||g(this._events.error)&&!this._events.error.length)){if((b=arguments[1])instanceof Error)throw b;var k=new Error('Uncaught, unspecified "error" event. ('+b+")");throw k.context=b,k}if(c=this._events[a],h(c))return!1
+;if(e(c))switch(arguments.length){case 1:c.call(this);break;case 2:c.call(this,arguments[1]);break;case 3:c.call(this,arguments[1],arguments[2]);break;default:f=Array.prototype.slice.call(arguments,1),c.apply(this,f)}else if(g(c))for(f=Array.prototype.slice.call(arguments,1),j=c.slice(),d=j.length,i=0;i<d;i++)j[i].apply(this,f);return!0},d.prototype.addListener=function(a,b){var c;if(!e(b))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",a,e(b.listener)?b.listener:b),this._events[a]?g(this._events[a])?this._events[a].push(b):this._events[a]=[this._events[a],b]:this._events[a]=b,g(this._events[a])&&!this._events[a].warned&&(c=h(this._maxListeners)?d.defaultMaxListeners:this._maxListeners)&&c>0&&this._events[a].length>c&&(this._events[a].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[a].length),"function"==typeof console.trace&&console.trace()),this},d.prototype.on=d.prototype.addListener,d.prototype.once=function(a,b){function c(){this.removeListener(a,c),d||(d=!0,b.apply(this,arguments))}if(!e(b))throw TypeError("listener must be a function");var d=!1;return c.listener=b,this.on(a,c),this},d.prototype.removeListener=function(a,b){var c,d,f,h;if(!e(b))throw TypeError("listener must be a function");if(!this._events||!this._events[a])return this;if(c=this._events[a],f=c.length,d=-1,c===b||e(c.listener)&&c.listener===b)delete this._events[a],this._events.removeListener&&this.emit("removeListener",a,b);else if(g(c)){for(h=f;h-- >0;)if(c[h]===b||c[h].listener&&c[h].listener===b){d=h;break}if(d<0)return this;1===c.length?(c.length=0,delete this._events[a]):c.splice(d,1),this._events.removeListener&&this.emit("removeListener",a,b)}return this},d.prototype.removeAllListeners=function(a){var b,c;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[a]&&delete this._events[a],this;if(0===arguments.length){for(b in this._events)"removeListener"!==b&&this.removeAllListeners(b);return this.removeAllListeners("removeListener"),this._events={},this}if(c=this._events[a],e(c))this.removeListener(a,c);else if(c)for(;c.length;)this.removeListener(a,c[c.length-1]);return delete this._events[a],this},d.prototype.listeners=function(a){return this._events&&this._events[a]?e(this._events[a])?[this._events[a]]:this._events[a].slice():[]},d.prototype.listenerCount=function(a){if(this._events){var b=this._events[a];if(e(b))return 1;if(b)return b.length}return 0},d.listenerCount=function(a,b){return a.listenerCount(b)}},{}],74:[function(a,b,c){var d=a("http"),e=b.exports;for(var f in d)d.hasOwnProperty(f)&&(e[f]=d[f]);e.request=function(a,b){return a||(a={}),a.scheme="https",a.protocol="https:",d.request.call(this,a,b)}},{http:94}],75:[function(a,b,c){"function"==typeof Object.create?b.exports=function(a,b){a.super_=b,a.prototype=Object.create(b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}})}:b.exports=function(a,b){a.super_=b;var c=function(){};c.prototype=b.prototype,a.prototype=new c,a.prototype.constructor=a}},{}],76:[function(a,b,c){function d(a){return!!a.constructor&&"function"==typeof a.constructor.isBuffer&&a.constructor.isBuffer(a)}function e(a){return"function"==typeof a.readFloatLE&&"function"==typeof a.slice&&d(a.slice(0,0))}b.exports=function(a){return null!=a&&(d(a)||e(a)||!!a._isBuffer)}},{}],77:[function(a,b,c){function d(){throw new Error("setTimeout has not been defined")}function e(){throw new Error("clearTimeout has not been defined")}function f(a){if(l===setTimeout)return setTimeout(a,0);if((l===d||!l)&&setTimeout)return l=setTimeout,setTimeout(a,0);try{return l(a,0)}catch(b){try{return l.call(null,a,0)}catch(b){return l.call(this,a,0)}}}function g(a){if(m===clearTimeout)return clearTimeout(a);if((m===e||!m)&&clearTimeout)return m=clearTimeout,clearTimeout(a);try{return m(a)}catch(b){try{return m.call(null,a)}catch(b){return m.call(this,a)}}}function h(){q&&o&&(q=!1,o.length?p=o.concat(p):r=-1,p.length&&i())}function i(){if(!q){var a=f(h);q=!0;for(var b=p.length;b;){for(o=p,p=[];++r<b;)o&&o[r].run();r=-1,b=p.length}o=null,q=!1,g(a)}}function j(a,b){this.fun=a,this.array=b}function k(){}var l,m,n=b.exports={};!function(){try{l="function"==typeof setTimeout?setTimeout:d}catch(a){l=d}try{m="function"==typeof clearTimeout?clearTimeout:e}catch(a){m=e}}();var o,p=[],q=!1,r=-1;n.nextTick=function(a){var b=new Array(arguments.length-1);if(arguments.length>1)for(var c=1;c<arguments.length;c++)b[c-1]=arguments[c];p.push(new j(a,b)),1!==p.length||q||f(i)},j.prototype.run=function(){this.fun.apply(null,this.array)},n.title="browser",n.browser=!0,n.env={},n.argv=[],n.version="",n.versions={},n.on=k,n.addListener=k,n.once=k,n.off=k,n.removeListener=k,n.removeAllListeners=k,n.emit=k,n.binding=function(a){throw new Error("process.binding is not supported")},n.cwd=function(){return"/"},n.chdir=function(a){throw new Error("process.chdir is not supported")},n.umask=function(){return 0}},{}],78:[function(a,b,c){(function(a){!function(d){function e(a){throw new RangeError(H[a])}function f(a,b){for(var c=a.length,d=[];c--;)d[c]=b(a[c]);return d}function g(a,b){var c=a.split("@"),d="";return c.length>1&&(d=c[0]+"@",a=c[1]),a=a.replace(G,"."),d+f(a.split("."),b).join(".")}function h(a){for(var b,c,d=[],e=0,f=a.length;e<f;)b=a.charCodeAt(e++),b>=55296&&b<=56319&&e<f?(c=a.charCodeAt(e++),56320==(64512&c)?d.push(((1023&b)<<10)+(1023&c)+65536):(d.push(b),e--)):d.push(b);return d}function i(a){return f(a,function(a){var b="";return a>65535&&(a-=65536,b+=K(a>>>10&1023|55296),a=56320|1023&a),b+=K(a)}).join("")}function j(a){return a-48<10?a-22:a-65<26?a-65:a-97<26?a-97:w}function k(a,b){return a+22+75*(a<26)-((0!=b)<<5)}function l(a,b,c){var d=0;for(a=c?J(a/A):a>>1,a+=J(a/b);a>I*y>>1;d+=w)a=J(a/I);return J(d+(I+1)*a/(a+z))}function m(a){var b,c,d,f,g,h,k,m,n,o,p=[],q=a.length,r=0,s=C,t=B;for(c=a.lastIndexOf(D),c<0&&(c=0),d=0;d<c;++d)a.charCodeAt(d)>=128&&e("not-basic"),p.push(a.charCodeAt(d));for(f=c>0?c+1:0;f<q;){for(g=r,h=1,k=w;f>=q&&e("invalid-input"),m=j(a.charCodeAt(f++)),(m>=w||m>J((v-r)/h))&&e("overflow"),r+=m*h,n=k<=t?x:k>=t+y?y:k-t,!(m<n);k+=w)o=w-n,h>J(v/o)&&e("overflow"),h*=o;b=p.length+1,t=l(r-g,b,0==g),J(r/b)>v-s&&e("overflow"),s+=J(r/b),r%=b,p.splice(r++,0,s)}return i(p)}function n(a){var b,c,d,f,g,i,j,m,n,o,p,q,r,s,t,u=[];for(a=h(a),q=a.length,b=C,c=0,g=B,i=0;i<q;++i)(p=a[i])<128&&u.push(K(p));for(d=f=u.length,f&&u.push(D);d<q;){for(j=v,i=0;i<q;++i)(p=a[i])>=b&&p<j&&(j=p);for(r=d+1,j-b>J((v-c)/r)&&e("overflow"),c+=(j-b)*r,b=j,i=0;i<q;++i)if(p=a[i],p<b&&++c>v&&e("overflow"),p==b){for(m=c,n=w;o=n<=g?x:n>=g+y?y:n-g,!(m<o);n+=w)t=m-o,s=w-o,u.push(K(k(o+t%s,0))),m=J(t/s);u.push(K(k(m,0))),g=l(c,r,d==f),c=0,++d}++c,++b}return u.join("")}function o(a){return g(a,function(a){return E.test(a)?m(a.slice(4).toLowerCase()):a})}function p(a){return g(a,function(a){return F.test(a)?"xn--"+n(a):a})}var q="object"==typeof c&&c&&!c.nodeType&&c,r="object"==typeof b&&b&&!b.nodeType&&b,s="object"==typeof a&&a;s.global!==s&&s.window!==s&&s.self!==s||(d=s);var t,u,v=2147483647,w=36,x=1,y=26,z=38,A=700,B=72,C=128,D="-",E=/^xn--/,F=/[^\x20-\x7E]/,G=/[\x2E\u3002\uFF0E\uFF61]/g,H={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},I=w-x,J=Math.floor,K=String.fromCharCode;if(t={version:"1.4.1",ucs2:{decode:h,encode:i},decode:m,encode:n,toASCII:p,toUnicode:o},"function"==typeof define&&"object"==typeof define.amd&&define.amd)define("punycode",function(){return t});else if(q&&r)if(b.exports==q)r.exports=t;else for(u in t)t.hasOwnProperty(u)&&(q[u]=t[u]);else d.punycode=t}(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],79:[function(a,b,c){"use strict";function d(a,b){return Object.prototype.hasOwnProperty.call(a,b)}b.exports=function(a,b,c,f){b=b||"&",c=c||"=";var g={};if("string"!=typeof a||0===a.length)return g;a=a.split(b);var h=1e3;f&&"number"==typeof f.maxKeys&&(h=f.maxKeys);var i=a.length;h>0&&i>h&&(i=h);for(var j=0;j<i;++j){var k,l,m,n,o=a[j].replace(/\+/g,"%20"),p=o.indexOf(c);p>=0?(k=o.substr(0,p),l=o.substr(p+1)):(k=o,l=""),m=decodeURIComponent(k),n=decodeURIComponent(l),d(g,m)?e(g[m])?g[m].push(n):g[m]=[g[m],n]:g[m]=n}return g};var e=Array.isArray||function(a){return"[object Array]"===Object.prototype.toString.call(a)}},{}],80:[function(a,b,c){"use strict";function d(a,b){if(a.map)return a.map(b);for(var c=[],d=0;d<a.length;d++)c.push(b(a[d],d));return c}var e=function(a){switch(typeof a){case"string":return a;case"boolean":return a?"true":"false";case"number":return isFinite(a)?a:"";default:return""}};b.exports=function(a,b,c,h){return b=b||"&",c=c||"=",null===a&&(a=void 0),"object"==typeof a?d(g(a),function(g){var h=encodeURIComponent(e(g))+c;return f(a[g])?d(a[g],function(a){return h+encodeURIComponent(e(a))}).join(b):h+encodeURIComponent(e(a[g]))}).join(b):h?encodeURIComponent(e(h))+c+encodeURIComponent(e(a)):""};var f=Array.isArray||function(a){return"[object Array]"===Object.prototype.toString.call(a)},g=Object.keys||function(a){var b=[];for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&b.push(c);return b}},{}],81:[function(a,b,c){"use strict";c.decode=c.parse=a("./decode"),c.encode=c.stringify=a("./encode")},{"./decode":79,"./encode":80}],82:[function(a,b,c){"use strict";function d(a){if(!(this instanceof d))return new d(a);j.call(this,a),k.call(this,a),a&&a.readable===!1&&(this.readable=!1),a&&a.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,a&&a.allowHalfOpen===!1&&(this.allowHalfOpen=!1),this.once("end",e)}function e(){this.allowHalfOpen||this._writableState.ended||h(f,this)}function f(a){a.end()}var g=Object.keys||function(a){var b=[];for(var c in a)b.push(c);return b};b.exports=d;var h=a("process-nextick-args"),i=a("core-util-is");i.inherits=a("inherits");var j=a("./_stream_readable"),k=a("./_stream_writable");i.inherits(d,j);for(var l=g(k.prototype),m=0;m<l.length;m++){var n=l[m];d.prototype[n]||(d.prototype[n]=k.prototype[n])}},{"./_stream_readable":84,"./_stream_writable":86,"core-util-is":89,inherits:75,"process-nextick-args":91}],83:[function(a,b,c){"use strict";function d(a){if(!(this instanceof d))return new d(a);e.call(this,a)}b.exports=d;var e=a("./_stream_transform"),f=a("core-util-is");f.inherits=a("inherits"),f.inherits(d,e),d.prototype._transform=function(a,b,c){c(null,a)}},{"./_stream_transform":85,"core-util-is":89,inherits:75}],84:[function(a,b,c){(function(c){"use strict";function d(a,b,c){if("function"==typeof a.prependListener)return a.prependListener(b,c);a._events&&a._events[b]?F(a._events[b])?a._events[b].unshift(c):a._events[b]=[c,a._events[b]]:a.on(b,c)}function e(b,c){D=D||a("./_stream_duplex"),b=b||{},this.objectMode=!!b.objectMode,c instanceof D&&(this.objectMode=this.objectMode||!!b.readableObjectMode);var d=b.highWaterMark,e=this.objectMode?16:16384;this.highWaterMark=d||0===d?d:e,this.highWaterMark=~~this.highWaterMark,this.buffer=new O,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.resumeScheduled=!1,this.defaultEncoding=b.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,b.encoding&&(N||(N=a("string_decoder/").StringDecoder),this.decoder=new N(b.encoding),this.encoding=b.encoding)}function f(b){if(D=D||a("./_stream_duplex"),!(this instanceof f))return new f(b);this._readableState=new e(b,this),this.readable=!0,b&&"function"==typeof b.read&&(this._read=b.read),G.call(this)}function g(a,b,c,d,e){var f=k(b,c);if(f)a.emit("error",f);else if(null===c)b.reading=!1,l(a,b);else if(b.objectMode||c&&c.length>0)if(b.ended&&!e){var g=new Error("stream.push() after EOF");a.emit("error",g)}else if(b.endEmitted&&e){var i=new Error("stream.unshift() after end event");a.emit("error",i)}else{var j;!b.decoder||e||d||(c=b.decoder.write(c),j=!b.objectMode&&0===c.length),e||(b.reading=!1),j||(b.flowing&&0===b.length&&!b.sync?(a.emit("data",c),a.read(0)):(b.length+=b.objectMode?1:c.length,e?b.buffer.unshift(c):b.buffer.push(c),b.needReadable&&m(a))),o(a,b)}else e||(b.reading=!1);return h(b)}function h(a){return!a.ended&&(a.needReadable||a.length<a.highWaterMark||0===a.length)}function i(a){return a>=P?a=P:(a--,a|=a>>>1,a|=a>>>2,a|=a>>>4,a|=a>>>8,a|=a>>>16,a++),a}function j(a,b){return a<=0||0===b.length&&b.ended?0:b.objectMode?1:a!==a?b.flowing&&b.length?b.buffer.head.data.length:b.length:(a>b.highWaterMark&&(b.highWaterMark=i(a)),a<=b.length?a:b.ended?b.length:(b.needReadable=!0,0))}function k(a,b){var c=null;return I.isBuffer(b)||"string"==typeof b||null===b||void 0===b||a.objectMode||(c=new TypeError("Invalid non-string/buffer chunk")),c}function l(a,b){if(!b.ended){if(b.decoder){var c=b.decoder.end();c&&c.length&&(b.buffer.push(c),b.length+=b.objectMode?1:c.length)}b.ended=!0,m(a)}}function m(a){var b=a._readableState;b.needReadable=!1,b.emittedReadable||(M("emitReadable",b.flowing),b.emittedReadable=!0,b.sync?E(n,a):n(a))}function n(a){M("emit readable"),a.emit("readable"),u(a)}function o(a,b){b.readingMore||(b.readingMore=!0,E(p,a,b))}function p(a,b){for(var c=b.length;!b.reading&&!b.flowing&&!b.ended&&b.length<b.highWaterMark&&(M("maybeReadMore read 0"),a.read(0),c!==b.length);)c=b.length;b.readingMore=!1}function q(a){return function(){var b=a._readableState;M("pipeOnDrain",b.awaitDrain),b.awaitDrain&&b.awaitDrain--,0===b.awaitDrain&&H(a,"data")&&(b.flowing=!0,u(a))}}function r(a){M("readable nexttick read 0"),a.read(0)}function s(a,b){b.resumeScheduled||(b.resumeScheduled=!0,E(t,a,b))}function t(a,b){b.reading||(M("resume read 0"),a.read(0)),b.resumeScheduled=!1,b.awaitDrain=0,a.emit("resume"),u(a),b.flowing&&!b.reading&&a.read(0)}function u(a){var b=a._readableState;for(M("flow",b.flowing);b.flowing&&null!==a.read(););}function v(a,b){if(0===b.length)return null;var c;return b.objectMode?c=b.buffer.shift():!a||a>=b.length?(c=b.decoder?b.buffer.join(""):1===b.buffer.length?b.buffer.head.data:b.buffer.concat(b.length),b.buffer.clear()):c=w(a,b.buffer,b.decoder),c}function w(a,b,c){var d;return a<b.head.data.length?(d=b.head.data.slice(0,a),b.head.data=b.head.data.slice(a)):d=a===b.head.data.length?b.shift():c?x(a,b):y(a,b),d}function x(a,b){var c=b.head,d=1,e=c.data;for(a-=e.length;c=c.next;){var f=c.data,g=a>f.length?f.length:a;if(e+=g===f.length?f:f.slice(0,a),0===(a-=g)){g===f.length?(++d,c.next?b.head=c.next:b.head=b.tail=null):(b.head=c,c.data=f.slice(g));break}++d}return b.length-=d,e}function y(a,b){var c=J.allocUnsafe(a),d=b.head,e=1;for(d.data.copy(c),a-=d.data.length;d=d.next;){var f=d.data,g=a>f.length?f.length:a;if(f.copy(c,c.length-a,0,g),0===(a-=g)){g===f.length?(++e,d.next?b.head=d.next:b.head=b.tail=null):(b.head=d,d.data=f.slice(g));break}++e}return b.length-=e,c}function z(a){var b=a._readableState;if(b.length>0)throw new Error('"endReadable()" called on non-empty stream');b.endEmitted||(b.ended=!0,E(A,b,a))}function A(a,b){a.endEmitted||0!==a.length||(a.endEmitted=!0,b.readable=!1,b.emit("end"))}function B(a,b){for(var c=0,d=a.length;c<d;c++)b(a[c],c)}function C(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1}b.exports=f;var D,E=a("process-nextick-args"),F=a("isarray");f.ReadableState=e;var G,H=(a("events").EventEmitter,function(a,b){return a.listeners(b).length});!function(){try{G=a("stream")}catch(a){}finally{G||(G=a("events").EventEmitter)}}();var I=a("buffer").Buffer,J=a("buffer-shims"),K=a("core-util-is");K.inherits=a("inherits");var L=a("util"),M=void 0;M=L&&L.debuglog?L.debuglog("stream"):function(){};var N,O=a("./internal/streams/BufferList");K.inherits(f,G),f.prototype.push=function(a,b){var c=this._readableState;return c.objectMode||"string"!=typeof a||(b=b||c.defaultEncoding)!==c.encoding&&(a=J.from(a,b),b=""),g(this,c,a,b,!1)},f.prototype.unshift=function(a){return g(this,this._readableState,a,"",!0)},f.prototype.isPaused=function(){return this._readableState.flowing===!1},f.prototype.setEncoding=function(b){return N||(N=a("string_decoder/").StringDecoder),this._readableState.decoder=new N(b),this._readableState.encoding=b,this};var P=8388608;f.prototype.read=function(a){M("read",a),a=parseInt(a,10);var b=this._readableState,c=a;if(0!==a&&(b.emittedReadable=!1),0===a&&b.needReadable&&(b.length>=b.highWaterMark||b.ended))return M("read: emitReadable",b.length,b.ended),0===b.length&&b.ended?z(this):m(this),null;if(0===(a=j(a,b))&&b.ended)return 0===b.length&&z(this),null;var d=b.needReadable;M("need readable",d),(0===b.length||b.length-a<b.highWaterMark)&&(d=!0,M("length less than watermark",d)),b.ended||b.reading?(d=!1,M("reading or ended",d)):d&&(M("do read"),b.reading=!0,b.sync=!0,0===b.length&&(b.needReadable=!0),this._read(b.highWaterMark),b.sync=!1,b.reading||(a=j(c,b)));var e;return e=a>0?v(a,b):null,null===e?(b.needReadable=!0,a=0):b.length-=a,0===b.length&&(b.ended||(b.needReadable=!0),c!==a&&b.ended&&z(this)),null!==e&&this.emit("data",e),e},f.prototype._read=function(a){this.emit("error",new Error("_read() is not implemented"))},f.prototype.pipe=function(a,b){function e(a){M("onunpipe"),a===m&&g()}function f(){M("onend"),a.end()}function g(){M("cleanup"),a.removeListener("close",j),a.removeListener("finish",k),a.removeListener("drain",r),a.removeListener("error",i),a.removeListener("unpipe",e),m.removeListener("end",f),m.removeListener("end",g),m.removeListener("data",h),s=!0,!n.awaitDrain||a._writableState&&!a._writableState.needDrain||r()}function h(b){M("ondata"),t=!1,!1!==a.write(b)||t||((1===n.pipesCount&&n.pipes===a||n.pipesCount>1&&C(n.pipes,a)!==-1)&&!s&&(M("false write response, pause",m._readableState.awaitDrain),m._readableState.awaitDrain++,t=!0),m.pause())}function i(b){M("onerror",b),l(),a.removeListener("error",i),0===H(a,"error")&&a.emit("error",b)}function j(){a.removeListener("finish",k),l()}function k(){M("onfinish"),a.removeListener("close",j),l()}function l(){M("unpipe"),m.unpipe(a)}var m=this,n=this._readableState;switch(n.pipesCount){case 0:n.pipes=a;break;case 1:n.pipes=[n.pipes,a];break;default:n.pipes.push(a)}n.pipesCount+=1,M("pipe count=%d opts=%j",n.pipesCount,b);var o=(!b||b.end!==!1)&&a!==c.stdout&&a!==c.stderr,p=o?f:g;n.endEmitted?E(p):m.once("end",p),a.on("unpipe",e);var r=q(m);a.on("drain",r);var s=!1,t=!1;return m.on("data",h),d(a,"error",i),a.once("close",j),a.once("finish",k),a.emit("pipe",m),n.flowing||(M("pipe resume"),m.resume()),a},f.prototype.unpipe=function(a){var b=this._readableState;if(0===b.pipesCount)return this;if(1===b.pipesCount)return a&&a!==b.pipes?this:(a||(a=b.pipes),b.pipes=null,b.pipesCount=0,b.flowing=!1,a&&a.emit("unpipe",this),this);if(!a){var c=b.pipes,d=b.pipesCount;b.pipes=null,b.pipesCount=0,b.flowing=!1;for(var e=0;e<d;e++)c[e].emit("unpipe",this);return this}var f=C(b.pipes,a);return f===-1?this:(b.pipes.splice(f,1),b.pipesCount-=1,1===b.pipesCount&&(b.pipes=b.pipes[0]),a.emit("unpipe",this),this)},f.prototype.on=function(a,b){var c=G.prototype.on.call(this,a,b);if("data"===a)this._readableState.flowing!==!1&&this.resume();else if("readable"===a){var d=this._readableState;d.endEmitted||d.readableListening||(d.readableListening=d.needReadable=!0,d.emittedReadable=!1,d.reading?d.length&&m(this):E(r,this))}return c},f.prototype.addListener=f.prototype.on,f.prototype.resume=function(){var a=this._readableState;return a.flowing||(M("resume"),a.flowing=!0,s(this,a)),this},f.prototype.pause=function(){return M("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(M("pause"),this._readableState.flowing=!1,this.emit("pause")),this},f.prototype.wrap=function(a){var b=this._readableState,c=!1,d=this;a.on("end",function(){if(M("wrapped end"),b.decoder&&!b.ended){var a=b.decoder.end();a&&a.length&&d.push(a)}d.push(null)}),a.on("data",function(e){if(M("wrapped data"),b.decoder&&(e=b.decoder.write(e)),(!b.objectMode||null!==e&&void 0!==e)&&(b.objectMode||e&&e.length)){d.push(e)||(c=!0,a.pause())}});for(var e in a)void 0===this[e]&&"function"==typeof a[e]&&(this[e]=function(b){return function(){return a[b].apply(a,arguments)}}(e));return B(["error","close","destroy","pause","resume"],function(b){a.on(b,d.emit.bind(d,b))}),d._read=function(b){M("wrapped _read",b),c&&(c=!1,a.resume())},d},f._fromList=v}).call(this,a("_process"))},{"./_stream_duplex":82,"./internal/streams/BufferList":87,_process:77,buffer:69,"buffer-shims":88,"core-util-is":89,events:73,inherits:75,isarray:90,"process-nextick-args":91,"string_decoder/":100,util:68}],85:[function(a,b,c){"use strict";function d(a){this.afterTransform=function(b,c){return e(a,b,c)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null,this.writeencoding=null}function e(a,b,c){var d=a._transformState;d.transforming=!1;var e=d.writecb;if(!e)return a.emit("error",new Error("no writecb in Transform class"));d.writechunk=null,d.writecb=null,null!==c&&void 0!==c&&a.push(c),e(b);var f=a._readableState;f.reading=!1,(f.needReadable||f.length<f.highWaterMark)&&a._read(f.highWaterMark)}function f(a){if(!(this instanceof f))return new f(a);h.call(this,a),this._transformState=new d(this);var b=this;this._readableState.needReadable=!0,this._readableState.sync=!1,a&&("function"==typeof a.transform&&(this._transform=a.transform),"function"==typeof a.flush&&(this._flush=a.flush)),this.once("prefinish",function(){"function"==typeof this._flush?this._flush(function(a,c){g(b,a,c)}):g(b)})}function g(a,b,c){if(b)return a.emit("error",b);null!==c&&void 0!==c&&a.push(c);var d=a._writableState,e=a._transformState;if(d.length)throw new Error("Calling transform done when ws.length != 0");if(e.transforming)throw new Error("Calling transform done when still transforming");return a.push(null)}b.exports=f;var h=a("./_stream_duplex"),i=a("core-util-is");i.inherits=a("inherits"),i.inherits(f,h),f.prototype.push=function(a,b){return this._transformState.needTransform=!1,h.prototype.push.call(this,a,b)},f.prototype._transform=function(a,b,c){throw new Error("_transform() is not implemented")},f.prototype._write=function(a,b,c){var d=this._transformState;if(d.writecb=c,d.writechunk=a,d.writeencoding=b,!d.transforming){var e=this._readableState;(d.needTransform||e.needReadable||e.length<e.highWaterMark)&&this._read(e.highWaterMark)}},f.prototype._read=function(a){var b=this._transformState;null!==b.writechunk&&b.writecb&&!b.transforming?(b.transforming=!0,this._transform(b.writechunk,b.writeencoding,b.afterTransform)):b.needTransform=!0}},{"./_stream_duplex":82,"core-util-is":89,inherits:75}],86:[function(a,b,c){(function(c){"use strict";function d(){}function e(a,b,c){this.chunk=a,this.encoding=b,this.callback=c,this.next=null}function f(b,c){x=x||a("./_stream_duplex"),b=b||{},this.objectMode=!!b.objectMode,c instanceof x&&(this.objectMode=this.objectMode||!!b.writableObjectMode);var d=b.highWaterMark,e=this.objectMode?16:16384;this.highWaterMark=d||0===d?d:e,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var f=b.decodeStrings===!1;this.decodeStrings=!f,this.defaultEncoding=b.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(a){o(c,a)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new w(this)}function g(b){if(x=x||a("./_stream_duplex"),!(F.call(g,this)||this instanceof x))return new g(b);this._writableState=new f(b,this),this.writable=!0,b&&("function"==typeof b.write&&(this._write=b.write),"function"==typeof b.writev&&(this._writev=b.writev)),B.call(this)}function h(a,b){var c=new Error("write after end");a.emit("error",c),y(b,c)}function i(a,b,c,d){var e=!0,f=!1;return null===c?f=new TypeError("May not write null values to stream"):D.isBuffer(c)||"string"==typeof c||void 0===c||b.objectMode||(f=new TypeError("Invalid non-string/buffer chunk")),f&&(a.emit("error",f),y(d,f),e=!1),e}function j(a,b,c){return a.objectMode||a.decodeStrings===!1||"string"!=typeof b||(b=E.from(b,c)),b}function k(a,b,c,d,f){c=j(b,c,d),D.isBuffer(c)&&(d="buffer");var g=b.objectMode?1:c.length;b.length+=g;var h=b.length<b.highWaterMark;if(h||(b.needDrain=!0),b.writing||b.corked){var i=b.lastBufferedRequest;b.lastBufferedRequest=new e(c,d,f),i?i.next=b.lastBufferedRequest:b.bufferedRequest=b.lastBufferedRequest,b.bufferedRequestCount+=1}else l(a,b,!1,g,c,d,f);return h}function l(a,b,c,d,e,f,g){b.writelen=d,b.writecb=g,b.writing=!0,b.sync=!0,c?a._writev(e,b.onwrite):a._write(e,f,b.onwrite),b.sync=!1}function m(a,b,c,d,e){--b.pendingcb,c?y(e,d):e(d),a._writableState.errorEmitted=!0,a.emit("error",d)}function n(a){a.writing=!1,a.writecb=null,a.length-=a.writelen,a.writelen=0}function o(a,b){var c=a._writableState,d=c.sync,e=c.writecb;if(n(c),b)m(a,c,d,b,e);else{var f=s(c);f||c.corked||c.bufferProcessing||!c.bufferedRequest||r(a,c),d?z(p,a,c,f,e):p(a,c,f,e)}}function p(a,b,c,d){c||q(a,b),b.pendingcb--,d(),u(a,b)}function q(a,b){0===b.length&&b.needDrain&&(b.needDrain=!1,a.emit("drain"))}function r(a,b){b.bufferProcessing=!0;var c=b.bufferedRequest;if(a._writev&&c&&c.next){var d=b.bufferedRequestCount,e=new Array(d),f=b.corkedRequestsFree;f.entry=c;for(var g=0;c;)e[g]=c,c=c.next,g+=1;l(a,b,!0,b.length,e,"",f.finish),b.pendingcb++,b.lastBufferedRequest=null,f.next?(b.corkedRequestsFree=f.next,f.next=null):b.corkedRequestsFree=new w(b)}else{for(;c;){var h=c.chunk,i=c.encoding,j=c.callback;if(l(a,b,!1,b.objectMode?1:h.length,h,i,j),c=c.next,b.writing)break}null===c&&(b.lastBufferedRequest=null)}b.bufferedRequestCount=0,b.bufferedRequest=c,b.bufferProcessing=!1}function s(a){return a.ending&&0===a.length&&null===a.bufferedRequest&&!a.finished&&!a.writing}function t(a,b){b.prefinished||(b.prefinished=!0,a.emit("prefinish"))}function u(a,b){var c=s(b);return c&&(0===b.pendingcb?(t(a,b),b.finished=!0,a.emit("finish")):t(a,b)),c}function v(a,b,c){b.ending=!0,u(a,b),c&&(b.finished?y(c):a.once("finish",c)),b.ended=!0,a.writable=!1}function w(a){var b=this;this.next=null,this.entry=null,this.finish=function(c){var d=b.entry;for(b.entry=null;d;){var e=d.callback;a.pendingcb--,e(c),d=d.next}a.corkedRequestsFree?a.corkedRequestsFree.next=b:a.corkedRequestsFree=b}}b.exports=g;var x,y=a("process-nextick-args"),z=!c.browser&&["v0.10","v0.9."].indexOf(c.version.slice(0,5))>-1?setImmediate:y;g.WritableState=f;var A=a("core-util-is");A.inherits=a("inherits");var B,C={deprecate:a("util-deprecate")};!function(){try{B=a("stream")}catch(a){}finally{B||(B=a("events").EventEmitter)}}();var D=a("buffer").Buffer,E=a("buffer-shims");A.inherits(g,B),f.prototype.getBuffer=function(){for(var a=this.bufferedRequest,b=[];a;)b.push(a),a=a.next;return b},function(){try{Object.defineProperty(f.prototype,"buffer",{get:C.deprecate(function(){return this.getBuffer()},"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.")})}catch(a){}}();var F;"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(F=Function.prototype[Symbol.hasInstance],Object.defineProperty(g,Symbol.hasInstance,{value:function(a){return!!F.call(this,a)||a&&a._writableState instanceof f}})):F=function(a){return a instanceof this},g.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},g.prototype.write=function(a,b,c){var e=this._writableState,f=!1;return"function"==typeof b&&(c=b,b=null),D.isBuffer(a)?b="buffer":b||(b=e.defaultEncoding),"function"!=typeof c&&(c=d),e.ended?h(this,c):i(this,e,a,c)&&(e.pendingcb++,f=k(this,e,a,b,c)),f},g.prototype.cork=function(){this._writableState.corked++},g.prototype.uncork=function(){var a=this._writableState;a.corked&&(a.corked--,a.writing||a.corked||a.finished||a.bufferProcessing||!a.bufferedRequest||r(this,a))},g.prototype.setDefaultEncoding=function(a){if("string"==typeof a&&(a=a.toLowerCase()),!(["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le","raw"].indexOf((a+"").toLowerCase())>-1))throw new TypeError("Unknown encoding: "+a);return this._writableState.defaultEncoding=a,this},g.prototype._write=function(a,b,c){c(new Error("_write() is not implemented"))},g.prototype._writev=null,g.prototype.end=function(a,b,c){var d=this._writableState;"function"==typeof a?(c=a,a=null,b=null):"function"==typeof b&&(c=b,b=null),null!==a&&void 0!==a&&this.write(a,b),d.corked&&(d.corked=1,this.uncork()),d.ending||d.finished||v(this,d,c)}}).call(this,a("_process"))},{"./_stream_duplex":82,_process:77,buffer:69,"buffer-shims":88,"core-util-is":89,events:73,inherits:75,"process-nextick-args":91,"util-deprecate":92}],87:[function(a,b,c){"use strict";function d(){this.head=null,this.tail=null,this.length=0}var e=(a("buffer").Buffer,a("buffer-shims"));b.exports=d,d.prototype.push=function(a){var b={data:a,next:null};this.length>0?this.tail.next=b:this.head=b,this.tail=b,++this.length},d.prototype.unshift=function(a){var b={data:a,next:this.head};0===this.length&&(this.tail=b),this.head=b,++this.length},d.prototype.shift=function(){if(0!==this.length){var a=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,a}},d.prototype.clear=function(){this.head=this.tail=null,this.length=0},d.prototype.join=function(a){if(0===this.length)return"";for(var b=this.head,c=""+b.data;b=b.next;)c+=a+b.data;return c},d.prototype.concat=function(a){if(0===this.length)return e.alloc(0);if(1===this.length)return this.head.data;for(var b=e.allocUnsafe(a>>>0),c=this.head,d=0;c;)c.data.copy(b,d),d+=c.data.length,c=c.next;return b}},{buffer:69,"buffer-shims":88}],88:[function(a,b,c){(function(b){"use strict";var d=a("buffer"),e=d.Buffer,f=d.SlowBuffer,g=d.kMaxLength||2147483647;c.alloc=function(a,b,c){if("function"==typeof e.alloc)return e.alloc(a,b,c);if("number"==typeof c)throw new TypeError("encoding must not be number");if("number"!=typeof a)throw new TypeError("size must be a number");if(a>g)throw new RangeError("size is too large");var d=c,f=b;void 0===f&&(d=void 0,f=0);var h=new e(a);if("string"==typeof f)for(var i=new e(f,d),j=i.length,k=-1;++k<a;)h[k]=i[k%j];else h.fill(f);return h},c.allocUnsafe=function(a){if("function"==typeof e.allocUnsafe)return e.allocUnsafe(a);if("number"!=typeof a)throw new TypeError("size must be a number");if(a>g)throw new RangeError("size is too large");return new e(a)},c.from=function(a,c,d){if("function"==typeof e.from&&(!b.Uint8Array||Uint8Array.from!==e.from))return e.from(a,c,d);if("number"==typeof a)throw new TypeError('"value" argument must not be a number');if("string"==typeof a)return new e(a,c);if("undefined"!=typeof ArrayBuffer&&a instanceof ArrayBuffer){var f=c;if(1===arguments.length)return new e(a);void 0===f&&(f=0);var g=d;if(void 0===g&&(g=a.byteLength-f),f>=a.byteLength)throw new RangeError("'offset' is out of bounds");if(g>a.byteLength-f)throw new RangeError("'length' is out of bounds");return new e(a.slice(f,f+g))}if(e.isBuffer(a)){var h=new e(a.length);return a.copy(h,0,0,a.length),h}if(a){if(Array.isArray(a)||"undefined"!=typeof ArrayBuffer&&a.buffer instanceof ArrayBuffer||"length"in a)return new e(a);if("Buffer"===a.type&&Array.isArray(a.data))return new e(a.data)}throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")},c.allocUnsafeSlow=function(a){if("function"==typeof e.allocUnsafeSlow)return e.allocUnsafeSlow(a);if("number"!=typeof a)throw new TypeError("size must be a number");if(a>=g)throw new RangeError("size is too large")
+;return new f(a)}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{buffer:69}],89:[function(a,b,c){(function(a){function b(a){return Array.isArray?Array.isArray(a):"[object Array]"===q(a)}function d(a){return"boolean"==typeof a}function e(a){return null===a}function f(a){return null==a}function g(a){return"number"==typeof a}function h(a){return"string"==typeof a}function i(a){return"symbol"==typeof a}function j(a){return void 0===a}function k(a){return"[object RegExp]"===q(a)}function l(a){return"object"==typeof a&&null!==a}function m(a){return"[object Date]"===q(a)}function n(a){return"[object Error]"===q(a)||a instanceof Error}function o(a){return"function"==typeof a}function p(a){return null===a||"boolean"==typeof a||"number"==typeof a||"string"==typeof a||"symbol"==typeof a||void 0===a}function q(a){return Object.prototype.toString.call(a)}c.isArray=b,c.isBoolean=d,c.isNull=e,c.isNullOrUndefined=f,c.isNumber=g,c.isString=h,c.isSymbol=i,c.isUndefined=j,c.isRegExp=k,c.isObject=l,c.isDate=m,c.isError=n,c.isFunction=o,c.isPrimitive=p,c.isBuffer=a.isBuffer}).call(this,{isBuffer:a("../../../../insert-module-globals/node_modules/is-buffer/index.js")})},{"../../../../insert-module-globals/node_modules/is-buffer/index.js":76}],90:[function(a,b,c){arguments[4][72][0].apply(c,arguments)},{dup:72}],91:[function(a,b,c){(function(a){"use strict";function c(b,c,d,e){if("function"!=typeof b)throw new TypeError('"callback" argument must be a function');var f,g,h=arguments.length;switch(h){case 0:case 1:return a.nextTick(b);case 2:return a.nextTick(function(){b.call(null,c)});case 3:return a.nextTick(function(){b.call(null,c,d)});case 4:return a.nextTick(function(){b.call(null,c,d,e)});default:for(f=new Array(h-1),g=0;g<f.length;)f[g++]=arguments[g];return a.nextTick(function(){b.apply(null,f)})}}!a.version||0===a.version.indexOf("v0.")||0===a.version.indexOf("v1.")&&0!==a.version.indexOf("v1.8.")?b.exports=c:b.exports=a.nextTick}).call(this,a("_process"))},{_process:77}],92:[function(a,b,c){(function(a){function c(a,b){function c(){if(!e){if(d("throwDeprecation"))throw new Error(b);d("traceDeprecation")?console.trace(b):console.warn(b),e=!0}return a.apply(this,arguments)}if(d("noDeprecation"))return a;var e=!1;return c}function d(b){try{if(!a.localStorage)return!1}catch(a){return!1}var c=a.localStorage[b];return null!=c&&"true"===String(c).toLowerCase()}b.exports=c}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],93:[function(a,b,c){(function(d){var e=function(){try{return a("stream")}catch(a){}}();c=b.exports=a("./lib/_stream_readable.js"),c.Stream=e||c,c.Readable=c,c.Writable=a("./lib/_stream_writable.js"),c.Duplex=a("./lib/_stream_duplex.js"),c.Transform=a("./lib/_stream_transform.js"),c.PassThrough=a("./lib/_stream_passthrough.js"),!d.browser&&"disable"===d.env.READABLE_STREAM&&e&&(b.exports=e)}).call(this,a("_process"))},{"./lib/_stream_duplex.js":82,"./lib/_stream_passthrough.js":83,"./lib/_stream_readable.js":84,"./lib/_stream_transform.js":85,"./lib/_stream_writable.js":86,_process:77}],94:[function(a,b,c){(function(b){var d=a("./lib/request"),e=a("xtend"),f=a("builtin-status-codes"),g=a("url"),h=c;h.request=function(a,c){a="string"==typeof a?g.parse(a):e(a);var f=b.location.protocol.search(/^https?:$/)===-1?"http:":"",h=a.protocol||f,i=a.hostname||a.host,j=a.port,k=a.path||"/";i&&i.indexOf(":")!==-1&&(i="["+i+"]"),a.url=(i?h+"//"+i:"")+(j?":"+j:"")+k,a.method=(a.method||"GET").toUpperCase(),a.headers=a.headers||{};var l=new d(a);return c&&l.on("response",c),l},h.get=function(a,b){var c=h.request(a,b);return c.end(),c},h.Agent=function(){},h.Agent.defaultMaxSockets=4,h.STATUS_CODES=f,h.METHODS=["CHECKOUT","CONNECT","COPY","DELETE","GET","HEAD","LOCK","M-SEARCH","MERGE","MKACTIVITY","MKCOL","MOVE","NOTIFY","OPTIONS","PATCH","POST","PROPFIND","PROPPATCH","PURGE","PUT","REPORT","SEARCH","SUBSCRIBE","TRACE","UNLOCK","UNSUBSCRIBE"]}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./lib/request":96,"builtin-status-codes":98,url:101,xtend:103}],95:[function(a,b,c){(function(a){function b(){if(void 0!==f)return f;if(a.XMLHttpRequest){f=new a.XMLHttpRequest;try{f.open("GET",a.XDomainRequest?"/":"https://example.com")}catch(a){f=null}}else f=null;return f}function d(a){var c=b();if(!c)return!1;try{return c.responseType=a,c.responseType===a}catch(a){}return!1}function e(a){return"function"==typeof a}c.fetch=e(a.fetch)&&e(a.ReadableStream),c.blobConstructor=!1;try{new Blob([new ArrayBuffer(1)]),c.blobConstructor=!0}catch(a){}var f,g=void 0!==a.ArrayBuffer,h=g&&e(a.ArrayBuffer.prototype.slice);c.arraybuffer=c.fetch||g&&d("arraybuffer"),c.msstream=!c.fetch&&h&&d("ms-stream"),c.mozchunkedarraybuffer=!c.fetch&&g&&d("moz-chunked-arraybuffer"),c.overrideMimeType=c.fetch||!!b()&&e(b().overrideMimeType),c.vbArray=e(a.VBArray),f=null}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],96:[function(a,b,c){(function(c,d,e){function f(a,b){return h.fetch&&b?"fetch":h.mozchunkedarraybuffer?"moz-chunked-arraybuffer":h.msstream?"ms-stream":h.arraybuffer&&a?"arraybuffer":h.vbArray&&a?"text:vbarray":"text"}function g(a){try{var b=a.status;return null!==b&&0!==b}catch(a){return!1}}var h=a("./capability"),i=a("inherits"),j=a("./response"),k=a("readable-stream"),l=a("to-arraybuffer"),m=j.IncomingMessage,n=j.readyStates,o=b.exports=function(a){var b=this;k.Writable.call(b),b._opts=a,b._body=[],b._headers={},a.auth&&b.setHeader("Authorization","Basic "+new e(a.auth).toString("base64")),Object.keys(a.headers).forEach(function(c){b.setHeader(c,a.headers[c])});var c,d=!0;if("disable-fetch"===a.mode||"timeout"in a)d=!1,c=!0;else if("prefer-streaming"===a.mode)c=!1;else if("allow-wrong-content-type"===a.mode)c=!h.overrideMimeType;else{if(a.mode&&"default"!==a.mode&&"prefer-fast"!==a.mode)throw new Error("Invalid value for opts.mode");c=!0}b._mode=f(c,d),b.on("finish",function(){b._onFinish()})};i(o,k.Writable),o.prototype.setHeader=function(a,b){var c=this,d=a.toLowerCase();p.indexOf(d)===-1&&(c._headers[d]={name:a,value:b})},o.prototype.getHeader=function(a){return this._headers[a.toLowerCase()].value},o.prototype.removeHeader=function(a){delete this._headers[a.toLowerCase()]},o.prototype._onFinish=function(){var a=this;if(!a._destroyed){var b=a._opts,f=a._headers,g=null;if("POST"!==b.method&&"PUT"!==b.method&&"PATCH"!==b.method&&"MERGE"!==b.method||(g=h.blobConstructor?new d.Blob(a._body.map(function(a){return l(a)}),{type:(f["content-type"]||{}).value||""}):e.concat(a._body).toString()),"fetch"===a._mode){var i=Object.keys(f).map(function(a){return[f[a].name,f[a].value]});d.fetch(a._opts.url,{method:a._opts.method,headers:i,body:g||void 0,mode:"cors",credentials:b.withCredentials?"include":"same-origin"}).then(function(b){a._fetchResponse=b,a._connect()},function(b){a.emit("error",b)})}else{var j=a._xhr=new d.XMLHttpRequest;try{j.open(a._opts.method,a._opts.url,!0)}catch(b){return void c.nextTick(function(){a.emit("error",b)})}"responseType"in j&&(j.responseType=a._mode.split(":")[0]),"withCredentials"in j&&(j.withCredentials=!!b.withCredentials),"text"===a._mode&&"overrideMimeType"in j&&j.overrideMimeType("text/plain; charset=x-user-defined"),"timeout"in b&&(j.timeout=b.timeout,j.ontimeout=function(){a.emit("timeout")}),Object.keys(f).forEach(function(a){j.setRequestHeader(f[a].name,f[a].value)}),a._response=null,j.onreadystatechange=function(){switch(j.readyState){case n.LOADING:case n.DONE:a._onXHRProgress()}},"moz-chunked-arraybuffer"===a._mode&&(j.onprogress=function(){a._onXHRProgress()}),j.onerror=function(){a._destroyed||a.emit("error",new Error("XHR error"))};try{j.send(g)}catch(b){return void c.nextTick(function(){a.emit("error",b)})}}}},o.prototype._onXHRProgress=function(){var a=this;g(a._xhr)&&!a._destroyed&&(a._response||a._connect(),a._response._onXHRProgress())},o.prototype._connect=function(){var a=this;a._destroyed||(a._response=new m(a._xhr,a._fetchResponse,a._mode),a._response.on("error",function(b){a.emit("error",b)}),a.emit("response",a._response))},o.prototype._write=function(a,b,c){this._body.push(a),c()},o.prototype.abort=o.prototype.destroy=function(){var a=this;a._destroyed=!0,a._response&&(a._response._destroyed=!0),a._xhr&&a._xhr.abort()},o.prototype.end=function(a,b,c){var d=this;"function"==typeof a&&(c=a,a=void 0),k.Writable.prototype.end.call(d,a,b,c)},o.prototype.flushHeaders=function(){},o.prototype.setTimeout=function(){},o.prototype.setNoDelay=function(){},o.prototype.setSocketKeepAlive=function(){};var p=["accept-charset","accept-encoding","access-control-request-headers","access-control-request-method","connection","content-length","cookie","cookie2","date","dnt","expect","host","keep-alive","origin","referer","te","trailer","transfer-encoding","upgrade","user-agent","via"]}).call(this,a("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},a("buffer").Buffer)},{"./capability":95,"./response":97,_process:77,buffer:69,inherits:75,"readable-stream":93,"to-arraybuffer":99}],97:[function(a,b,c){(function(b,d,e){var f=a("./capability"),g=a("inherits"),h=a("readable-stream"),i=c.readyStates={UNSENT:0,OPENED:1,HEADERS_RECEIVED:2,LOADING:3,DONE:4},j=c.IncomingMessage=function(a,c,d){function g(){j.read().then(function(a){if(!i._destroyed){if(a.done)return void i.push(null);i.push(new e(a.value)),g()}}).catch(function(a){i.emit("error",a)})}var i=this;if(h.Readable.call(i),i._mode=d,i.headers={},i.rawHeaders=[],i.trailers={},i.rawTrailers=[],i.on("end",function(){b.nextTick(function(){i.emit("close")})}),"fetch"===d){i._fetchResponse=c,i.url=c.url,i.statusCode=c.status,i.statusMessage=c.statusText,c.headers.forEach(function(a,b){i.headers[b.toLowerCase()]=a,i.rawHeaders.push(b,a)});var j=c.body.getReader();g()}else{i._xhr=a,i._pos=0,i.url=a.responseURL,i.statusCode=a.status,i.statusMessage=a.statusText;if(a.getAllResponseHeaders().split(/\r?\n/).forEach(function(a){var b=a.match(/^([^:]+):\s*(.*)/);if(b){var c=b[1].toLowerCase();"set-cookie"===c?(void 0===i.headers[c]&&(i.headers[c]=[]),i.headers[c].push(b[2])):void 0!==i.headers[c]?i.headers[c]+=", "+b[2]:i.headers[c]=b[2],i.rawHeaders.push(b[1],b[2])}}),i._charset="x-user-defined",!f.overrideMimeType){var k=i.rawHeaders["mime-type"];if(k){var l=k.match(/;\s*charset=([^;])(;|$)/);l&&(i._charset=l[1].toLowerCase())}i._charset||(i._charset="utf-8")}}};g(j,h.Readable),j.prototype._read=function(){},j.prototype._onXHRProgress=function(){var a=this,b=a._xhr,c=null;switch(a._mode){case"text:vbarray":if(b.readyState!==i.DONE)break;try{c=new d.VBArray(b.responseBody).toArray()}catch(a){}if(null!==c){a.push(new e(c));break}case"text":try{c=b.responseText}catch(b){a._mode="text:vbarray";break}if(c.length>a._pos){var f=c.substr(a._pos);if("x-user-defined"===a._charset){for(var g=new e(f.length),h=0;h<f.length;h++)g[h]=255&f.charCodeAt(h);a.push(g)}else a.push(f,a._charset);a._pos=c.length}break;case"arraybuffer":if(b.readyState!==i.DONE||!b.response)break;c=b.response,a.push(new e(new Uint8Array(c)));break;case"moz-chunked-arraybuffer":if(c=b.response,b.readyState!==i.LOADING||!c)break;a.push(new e(new Uint8Array(c)));break;case"ms-stream":if(c=b.response,b.readyState!==i.LOADING)break;var j=new d.MSStreamReader;j.onprogress=function(){j.result.byteLength>a._pos&&(a.push(new e(new Uint8Array(j.result.slice(a._pos)))),a._pos=j.result.byteLength)},j.onload=function(){a.push(null)},j.readAsArrayBuffer(c)}a._xhr.readyState===i.DONE&&"ms-stream"!==a._mode&&a.push(null)}}).call(this,a("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},a("buffer").Buffer)},{"./capability":95,_process:77,buffer:69,inherits:75,"readable-stream":93}],98:[function(a,b,c){b.exports={100:"Continue",101:"Switching Protocols",102:"Processing",200:"OK",201:"Created",202:"Accepted",203:"Non-Authoritative Information",204:"No Content",205:"Reset Content",206:"Partial Content",207:"Multi-Status",208:"Already Reported",226:"IM Used",300:"Multiple Choices",301:"Moved Permanently",302:"Found",303:"See Other",304:"Not Modified",305:"Use Proxy",307:"Temporary Redirect",308:"Permanent Redirect",400:"Bad Request",401:"Unauthorized",402:"Payment Required",403:"Forbidden",404:"Not Found",405:"Method Not Allowed",406:"Not Acceptable",407:"Proxy Authentication Required",408:"Request Timeout",409:"Conflict",410:"Gone",411:"Length Required",412:"Precondition Failed",413:"Payload Too Large",414:"URI Too Long",415:"Unsupported Media Type",416:"Range Not Satisfiable",417:"Expectation Failed",418:"I'm a teapot",421:"Misdirected Request",422:"Unprocessable Entity",423:"Locked",424:"Failed Dependency",425:"Unordered Collection",426:"Upgrade Required",428:"Precondition Required",429:"Too Many Requests",431:"Request Header Fields Too Large",451:"Unavailable For Legal Reasons",500:"Internal Server Error",501:"Not Implemented",502:"Bad Gateway",503:"Service Unavailable",504:"Gateway Timeout",505:"HTTP Version Not Supported",506:"Variant Also Negotiates",507:"Insufficient Storage",508:"Loop Detected",509:"Bandwidth Limit Exceeded",510:"Not Extended",511:"Network Authentication Required"}},{}],99:[function(a,b,c){var d=a("buffer").Buffer;b.exports=function(a){if(a instanceof Uint8Array){if(0===a.byteOffset&&a.byteLength===a.buffer.byteLength)return a.buffer;if("function"==typeof a.buffer.slice)return a.buffer.slice(a.byteOffset,a.byteOffset+a.byteLength)}if(d.isBuffer(a)){for(var b=new Uint8Array(a.length),c=a.length,e=0;e<c;e++)b[e]=a[e];return b.buffer}throw new Error("Argument must be a Buffer")}},{buffer:69}],100:[function(a,b,c){function d(a){if(a&&!i(a))throw new Error("Unknown encoding: "+a)}function e(a){return a.toString(this.encoding)}function f(a){this.charReceived=a.length%2,this.charLength=this.charReceived?2:0}function g(a){this.charReceived=a.length%3,this.charLength=this.charReceived?3:0}var h=a("buffer").Buffer,i=h.isEncoding||function(a){switch(a&&a.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}},j=c.StringDecoder=function(a){switch(this.encoding=(a||"utf8").toLowerCase().replace(/[-_]/,""),d(a),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=f;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=g;break;default:return void(this.write=e)}this.charBuffer=new h(6),this.charReceived=0,this.charLength=0};j.prototype.write=function(a){for(var b="";this.charLength;){var c=a.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:a.length;if(a.copy(this.charBuffer,this.charReceived,0,c),this.charReceived+=c,this.charReceived<this.charLength)return"";a=a.slice(c,a.length),b=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var d=b.charCodeAt(b.length-1);if(!(d>=55296&&d<=56319)){if(this.charReceived=this.charLength=0,0===a.length)return b;break}this.charLength+=this.surrogateSize,b=""}this.detectIncompleteChar(a);var e=a.length;this.charLength&&(a.copy(this.charBuffer,0,a.length-this.charReceived,e),e-=this.charReceived),b+=a.toString(this.encoding,0,e);var e=b.length-1,d=b.charCodeAt(e);if(d>=55296&&d<=56319){var f=this.surrogateSize;return this.charLength+=f,this.charReceived+=f,this.charBuffer.copy(this.charBuffer,f,0,f),a.copy(this.charBuffer,0,0,f),b.substring(0,e)}return b},j.prototype.detectIncompleteChar=function(a){for(var b=a.length>=3?3:a.length;b>0;b--){var c=a[a.length-b];if(1==b&&c>>5==6){this.charLength=2;break}if(b<=2&&c>>4==14){this.charLength=3;break}if(b<=3&&c>>3==30){this.charLength=4;break}}this.charReceived=b},j.prototype.end=function(a){var b="";if(a&&a.length&&(b=this.write(a)),this.charReceived){var c=this.charReceived,d=this.charBuffer,e=this.encoding;b+=d.slice(0,c).toString(e)}return b}},{buffer:69}],101:[function(a,b,c){"use strict";function d(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}function e(a,b,c){if(a&&j.isObject(a)&&a instanceof d)return a;var e=new d;return e.parse(a,b,c),e}function f(a){return j.isString(a)&&(a=e(a)),a instanceof d?a.format():d.prototype.format.call(a)}function g(a,b){return e(a,!1,!0).resolve(b)}function h(a,b){return a?e(a,!1,!0).resolveObject(b):b}var i=a("punycode"),j=a("./util");c.parse=e,c.resolve=g,c.resolveObject=h,c.format=f,c.Url=d;var k=/^([a-z0-9.+-]+:)/i,l=/:[0-9]*$/,m=/^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,n=["<",">",'"',"`"," ","\r","\n","\t"],o=["{","}","|","\\","^","`"].concat(n),p=["'"].concat(o),q=["%","/","?",";","#"].concat(p),r=["/","?","#"],s={javascript:!0,"javascript:":!0},t={javascript:!0,"javascript:":!0},u={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},v=a("querystring");d.prototype.parse=function(a,b,c){if(!j.isString(a))throw new TypeError("Parameter 'url' must be a string, not "+typeof a);var d=a.indexOf("?"),e=d!==-1&&d<a.indexOf("#")?"?":"#",f=a.split(e);f[0]=f[0].replace(/\\/g,"/"),a=f.join(e);var g=a;if(g=g.trim(),!c&&1===a.split("#").length){var h=m.exec(g);if(h)return this.path=g,this.href=g,this.pathname=h[1],h[2]?(this.search=h[2],this.query=b?v.parse(this.search.substr(1)):this.search.substr(1)):b&&(this.search="",this.query={}),this}var l=k.exec(g);if(l){l=l[0];var n=l.toLowerCase();this.protocol=n,g=g.substr(l.length)}if(c||l||g.match(/^\/\/[^@\/]+@[^@\/]+/)){var o="//"===g.substr(0,2);!o||l&&t[l]||(g=g.substr(2),this.slashes=!0)}if(!t[l]&&(o||l&&!u[l])){for(var w=-1,x=0;x<r.length;x++){var y=g.indexOf(r[x]);y!==-1&&(w===-1||y<w)&&(w=y)}var z,A;A=w===-1?g.lastIndexOf("@"):g.lastIndexOf("@",w),A!==-1&&(z=g.slice(0,A),g=g.slice(A+1),this.auth=decodeURIComponent(z)),w=-1;for(var x=0;x<q.length;x++){var y=g.indexOf(q[x]);y!==-1&&(w===-1||y<w)&&(w=y)}w===-1&&(w=g.length),this.host=g.slice(0,w),g=g.slice(w),this.parseHost(),this.hostname=this.hostname||"";var B="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!B)for(var C=this.hostname.split(/\./),x=0,D=C.length;x<D;x++){var E=C[x];if(E&&!E.match(/^[+a-z0-9A-Z_-]{0,63}$/)){for(var F="",G=0,H=E.length;G<H;G++)F+=E.charCodeAt(G)>127?"x":E[G];if(!F.match(/^[+a-z0-9A-Z_-]{0,63}$/)){var I=C.slice(0,x),J=C.slice(x+1),K=E.match(/^([+a-z0-9A-Z_-]{0,63})(.*)$/);K&&(I.push(K[1]),J.unshift(K[2])),J.length&&(g="/"+J.join(".")+g),this.hostname=I.join(".");break}}}this.hostname.length>255?this.hostname="":this.hostname=this.hostname.toLowerCase(),B||(this.hostname=i.toASCII(this.hostname));var L=this.port?":"+this.port:"",M=this.hostname||"";this.host=M+L,this.href+=this.host,B&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==g[0]&&(g="/"+g))}if(!s[n])for(var x=0,D=p.length;x<D;x++){var N=p[x];if(g.indexOf(N)!==-1){var O=encodeURIComponent(N);O===N&&(O=escape(N)),g=g.split(N).join(O)}}var P=g.indexOf("#");P!==-1&&(this.hash=g.substr(P),g=g.slice(0,P));var Q=g.indexOf("?");if(Q!==-1?(this.search=g.substr(Q),this.query=g.substr(Q+1),b&&(this.query=v.parse(this.query)),g=g.slice(0,Q)):b&&(this.search="",this.query={}),g&&(this.pathname=g),u[n]&&this.hostname&&!this.pathname&&(this.pathname="/"),this.pathname||this.search){var L=this.pathname||"",R=this.search||"";this.path=L+R}return this.href=this.format(),this},d.prototype.format=function(){var a=this.auth||"";a&&(a=encodeURIComponent(a),a=a.replace(/%3A/i,":"),a+="@");var b=this.protocol||"",c=this.pathname||"",d=this.hash||"",e=!1,f="";this.host?e=a+this.host:this.hostname&&(e=a+(this.hostname.indexOf(":")===-1?this.hostname:"["+this.hostname+"]"),this.port&&(e+=":"+this.port)),this.query&&j.isObject(this.query)&&Object.keys(this.query).length&&(f=v.stringify(this.query));var g=this.search||f&&"?"+f||"";return b&&":"!==b.substr(-1)&&(b+=":"),this.slashes||(!b||u[b])&&e!==!1?(e="//"+(e||""),c&&"/"!==c.charAt(0)&&(c="/"+c)):e||(e=""),d&&"#"!==d.charAt(0)&&(d="#"+d),g&&"?"!==g.charAt(0)&&(g="?"+g),c=c.replace(/[?#]/g,function(a){return encodeURIComponent(a)}),g=g.replace("#","%23"),b+e+c+g+d},d.prototype.resolve=function(a){return this.resolveObject(e(a,!1,!0)).format()},d.prototype.resolveObject=function(a){if(j.isString(a)){var b=new d;b.parse(a,!1,!0),a=b}for(var c=new d,e=Object.keys(this),f=0;f<e.length;f++){var g=e[f];c[g]=this[g]}if(c.hash=a.hash,""===a.href)return c.href=c.format(),c;if(a.slashes&&!a.protocol){for(var h=Object.keys(a),i=0;i<h.length;i++){var k=h[i];"protocol"!==k&&(c[k]=a[k])}return u[c.protocol]&&c.hostname&&!c.pathname&&(c.path=c.pathname="/"),c.href=c.format(),c}if(a.protocol&&a.protocol!==c.protocol){if(!u[a.protocol]){for(var l=Object.keys(a),m=0;m<l.length;m++){var n=l[m];c[n]=a[n]}return c.href=c.format(),c}if(c.protocol=a.protocol,a.host||t[a.protocol])c.pathname=a.pathname;else{for(var o=(a.pathname||"").split("/");o.length&&!(a.host=o.shift()););a.host||(a.host=""),a.hostname||(a.hostname=""),""!==o[0]&&o.unshift(""),o.length<2&&o.unshift(""),c.pathname=o.join("/")}if(c.search=a.search,c.query=a.query,c.host=a.host||"",c.auth=a.auth,c.hostname=a.hostname||a.host,c.port=a.port,c.pathname||c.search){var p=c.pathname||"",q=c.search||"";c.path=p+q}return c.slashes=c.slashes||a.slashes,c.href=c.format(),c}var r=c.pathname&&"/"===c.pathname.charAt(0),s=a.host||a.pathname&&"/"===a.pathname.charAt(0),v=s||r||c.host&&a.pathname,w=v,x=c.pathname&&c.pathname.split("/")||[],o=a.pathname&&a.pathname.split("/")||[],y=c.protocol&&!u[c.protocol];if(y&&(c.hostname="",c.port=null,c.host&&(""===x[0]?x[0]=c.host:x.unshift(c.host)),c.host="",a.protocol&&(a.hostname=null,a.port=null,a.host&&(""===o[0]?o[0]=a.host:o.unshift(a.host)),a.host=null),v=v&&(""===o[0]||""===x[0])),s)c.host=a.host||""===a.host?a.host:c.host,c.hostname=a.hostname||""===a.hostname?a.hostname:c.hostname,c.search=a.search,c.query=a.query,x=o;else if(o.length)x||(x=[]),x.pop(),x=x.concat(o),c.search=a.search,c.query=a.query;else if(!j.isNullOrUndefined(a.search)){if(y){c.hostname=c.host=x.shift();var z=!!(c.host&&c.host.indexOf("@")>0)&&c.host.split("@");z&&(c.auth=z.shift(),c.host=c.hostname=z.shift())}return c.search=a.search,c.query=a.query,j.isNull(c.pathname)&&j.isNull(c.search)||(c.path=(c.pathname?c.pathname:"")+(c.search?c.search:"")),c.href=c.format(),c}if(!x.length)return c.pathname=null,c.search?c.path="/"+c.search:c.path=null,c.href=c.format(),c;for(var A=x.slice(-1)[0],B=(c.host||a.host||x.length>1)&&("."===A||".."===A)||""===A,C=0,D=x.length;D>=0;D--)A=x[D],"."===A?x.splice(D,1):".."===A?(x.splice(D,1),C++):C&&(x.splice(D,1),C--);if(!v&&!w)for(;C--;C)x.unshift("..");!v||""===x[0]||x[0]&&"/"===x[0].charAt(0)||x.unshift(""),B&&"/"!==x.join("/").substr(-1)&&x.push("");var E=""===x[0]||x[0]&&"/"===x[0].charAt(0);if(y){c.hostname=c.host=E?"":x.length?x.shift():"";var z=!!(c.host&&c.host.indexOf("@")>0)&&c.host.split("@");z&&(c.auth=z.shift(),c.host=c.hostname=z.shift())}return v=v||c.host&&x.length,v&&!E&&x.unshift(""),x.length?c.pathname=x.join("/"):(c.pathname=null,c.path=null),j.isNull(c.pathname)&&j.isNull(c.search)||(c.path=(c.pathname?c.pathname:"")+(c.search?c.search:"")),c.auth=a.auth||c.auth,c.slashes=c.slashes||a.slashes,c.href=c.format(),c},d.prototype.parseHost=function(){var a=this.host,b=l.exec(a);b&&(b=b[0],":"!==b&&(this.port=b.substr(1)),a=a.substr(0,a.length-b.length)),a&&(this.hostname=a)}},{"./util":102,punycode:78,querystring:81}],102:[function(a,b,c){"use strict";b.exports={isString:function(a){return"string"==typeof a},isObject:function(a){return"object"==typeof a&&null!==a},isNull:function(a){return null===a},isNullOrUndefined:function(a){return null==a}}},{}],103:[function(a,b,c){function d(){for(var a={},b=0;b<arguments.length;b++){var c=arguments[b];for(var d in c)e.call(c,d)&&(a[d]=c[d])}return a}b.exports=d;var e=Object.prototype.hasOwnProperty},{}],104:[function(a,b,c){arguments[4][3][0].apply(c,arguments)},{_process:77,dup:3}],105:[function(a,b,c){(function(){var a=this,d=a._,e={},f=Array.prototype,g=Object.prototype,h=Function.prototype,i=f.push,j=f.slice,k=f.concat,l=g.toString,m=g.hasOwnProperty,n=f.forEach,o=f.map,p=f.reduce,q=f.reduceRight,r=f.filter,s=f.every,t=f.some,u=f.indexOf,v=f.lastIndexOf,w=Array.isArray,x=Object.keys,y=h.bind,z=function(a){return a instanceof z?a:this instanceof z?void(this._wrapped=a):new z(a)};void 0!==c?(void 0!==b&&b.exports&&(c=b.exports=z),c._=z):a._=z,z.VERSION="1.5.2";var A=z.each=z.forEach=function(a,b,c){if(null!=a)if(n&&a.forEach===n)a.forEach(b,c);else if(a.length===+a.length){for(var d=0,f=a.length;d<f;d++)if(b.call(c,a[d],d,a)===e)return}else for(var g=z.keys(a),d=0,f=g.length;d<f;d++)if(b.call(c,a[g[d]],g[d],a)===e)return};z.map=z.collect=function(a,b,c){var d=[];return null==a?d:o&&a.map===o?a.map(b,c):(A(a,function(a,e,f){d.push(b.call(c,a,e,f))}),d)};var B="Reduce of empty array with no initial value";z.reduce=z.foldl=z.inject=function(a,b,c,d){var e=arguments.length>2;if(null==a&&(a=[]),p&&a.reduce===p)return d&&(b=z.bind(b,d)),e?a.reduce(b,c):a.reduce(b);if(A(a,function(a,f,g){e?c=b.call(d,c,a,f,g):(c=a,e=!0)}),!e)throw new TypeError(B);return c},z.reduceRight=z.foldr=function(a,b,c,d){var e=arguments.length>2;if(null==a&&(a=[]),q&&a.reduceRight===q)return d&&(b=z.bind(b,d)),e?a.reduceRight(b,c):a.reduceRight(b);var f=a.length;if(f!==+f){var g=z.keys(a);f=g.length}if(A(a,function(h,i,j){i=g?g[--f]:--f,e?c=b.call(d,c,a[i],i,j):(c=a[i],e=!0)}),!e)throw new TypeError(B);return c},z.find=z.detect=function(a,b,c){var d;return C(a,function(a,e,f){if(b.call(c,a,e,f))return d=a,!0}),d},z.filter=z.select=function(a,b,c){var d=[];return null==a?d:r&&a.filter===r?a.filter(b,c):(A(a,function(a,e,f){b.call(c,a,e,f)&&d.push(a)}),d)},z.reject=function(a,b,c){return z.filter(a,function(a,d,e){return!b.call(c,a,d,e)},c)},z.every=z.all=function(a,b,c){b||(b=z.identity);var d=!0;return null==a?d:s&&a.every===s?a.every(b,c):(A(a,function(a,f,g){if(!(d=d&&b.call(c,a,f,g)))return e}),!!d)};var C=z.some=z.any=function(a,b,c){b||(b=z.identity);var d=!1;return null==a?d:t&&a.some===t?a.some(b,c):(A(a,function(a,f,g){if(d||(d=b.call(c,a,f,g)))return e}),!!d)};z.contains=z.include=function(a,b){return null!=a&&(u&&a.indexOf===u?a.indexOf(b)!=-1:C(a,function(a){return a===b}))},z.invoke=function(a,b){var c=j.call(arguments,2),d=z.isFunction(b);return z.map(a,function(a){return(d?b:a[b]).apply(a,c)})},z.pluck=function(a,b){return z.map(a,function(a){return a[b]})},z.where=function(a,b,c){return z.isEmpty(b)?c?void 0:[]:z[c?"find":"filter"](a,function(a){for(var c in b)if(b[c]!==a[c])return!1;return!0})},z.findWhere=function(a,b){return z.where(a,b,!0)},z.max=function(a,b,c){if(!b&&z.isArray(a)&&a[0]===+a[0]&&a.length<65535)return Math.max.apply(Math,a);if(!b&&z.isEmpty(a))return-(1/0);var d={computed:-(1/0),value:-(1/0)};return A(a,function(a,e,f){var g=b?b.call(c,a,e,f):a;g>d.computed&&(d={value:a,computed:g})}),d.value},z.min=function(a,b,c){if(!b&&z.isArray(a)&&a[0]===+a[0]&&a.length<65535)return Math.min.apply(Math,a);if(!b&&z.isEmpty(a))return 1/0;var d={computed:1/0,value:1/0};return A(a,function(a,e,f){var g=b?b.call(c,a,e,f):a;g<d.computed&&(d={value:a,computed:g})}),d.value},z.shuffle=function(a){var b,c=0,d=[];return A(a,function(a){b=z.random(c++),d[c-1]=d[b],d[b]=a}),d},z.sample=function(a,b,c){return arguments.length<2||c?a[z.random(a.length-1)]:z.shuffle(a).slice(0,Math.max(0,b))};var D=function(a){return z.isFunction(a)?a:function(b){return b[a]}};z.sortBy=function(a,b,c){var d=D(b);return z.pluck(z.map(a,function(a,b,e){return{value:a,index:b,criteria:d.call(c,a,b,e)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;if(c!==d){if(c>d||void 0===c)return 1;if(c<d||void 0===d)return-1}return a.index-b.index}),"value")};var E=function(a){return function(b,c,d){var e={},f=null==c?z.identity:D(c);return A(b,function(c,g){a(e,f.call(d,c,g,b),c)}),e}};z.groupBy=E(function(a,b,c){(z.has(a,b)?a[b]:a[b]=[]).push(c)}),z.indexBy=E(function(a,b,c){a[b]=c}),z.countBy=E(function(a,b){z.has(a,b)?a[b]++:a[b]=1}),z.sortedIndex=function(a,b,c,d){c=null==c?z.identity:D(c);for(var e=c.call(d,b),f=0,g=a.length;f<g;){var h=f+g>>>1;c.call(d,a[h])<e?f=h+1:g=h}return f},z.toArray=function(a){return a?z.isArray(a)?j.call(a):a.length===+a.length?z.map(a,z.identity):z.values(a):[]},z.size=function(a){return null==a?0:a.length===+a.length?a.length:z.keys(a).length},z.first=z.head=z.take=function(a,b,c){if(null!=a)return null==b||c?a[0]:j.call(a,0,b)},z.initial=function(a,b,c){return j.call(a,0,a.length-(null==b||c?1:b))},z.last=function(a,b,c){if(null!=a)return null==b||c?a[a.length-1]:j.call(a,Math.max(a.length-b,0))},z.rest=z.tail=z.drop=function(a,b,c){return j.call(a,null==b||c?1:b)},z.compact=function(a){return z.filter(a,z.identity)};var F=function(a,b,c){return b&&z.every(a,z.isArray)?k.apply(c,a):(A(a,function(a){z.isArray(a)||z.isArguments(a)?b?i.apply(c,a):F(a,b,c):c.push(a)}),c)};z.flatten=function(a,b){return F(a,b,[])},z.without=function(a){return z.difference(a,j.call(arguments,1))},z.uniq=z.unique=function(a,b,c,d){z.isFunction(b)&&(d=c,c=b,b=!1);var e=c?z.map(a,c,d):a,f=[],g=[];return A(e,function(c,d){(b?d&&g[g.length-1]===c:z.contains(g,c))||(g.push(c),f.push(a[d]))}),f},z.union=function(){return z.uniq(z.flatten(arguments,!0))},z.intersection=function(a){var b=j.call(arguments,1);return z.filter(z.uniq(a),function(a){return z.every(b,function(b){return z.indexOf(b,a)>=0})})},z.difference=function(a){var b=k.apply(f,j.call(arguments,1));return z.filter(a,function(a){return!z.contains(b,a)})},z.zip=function(){for(var a=z.max(z.pluck(arguments,"length").concat(0)),b=new Array(a),c=0;c<a;c++)b[c]=z.pluck(arguments,""+c);return b},z.object=function(a,b){if(null==a)return{};for(var c={},d=0,e=a.length;d<e;d++)b?c[a[d]]=b[d]:c[a[d][0]]=a[d][1];return c},z.indexOf=function(a,b,c){if(null==a)return-1;var d=0,e=a.length;if(c){if("number"!=typeof c)return d=z.sortedIndex(a,b),a[d]===b?d:-1;d=c<0?Math.max(0,e+c):c}if(u&&a.indexOf===u)return a.indexOf(b,c);for(;d<e;d++)if(a[d]===b)return d;return-1},z.lastIndexOf=function(a,b,c){if(null==a)return-1;var d=null!=c;if(v&&a.lastIndexOf===v)return d?a.lastIndexOf(b,c):a.lastIndexOf(b);for(var e=d?c:a.length;e--;)if(a[e]===b)return e;return-1},z.range=function(a,b,c){arguments.length<=1&&(b=a||0,a=0),c=arguments[2]||1;for(var d=Math.max(Math.ceil((b-a)/c),0),e=0,f=new Array(d);e<d;)f[e++]=a,a+=c;return f};var G=function(){};z.bind=function(a,b){var c,d;if(y&&a.bind===y)return y.apply(a,j.call(arguments,1));if(!z.isFunction(a))throw new TypeError;return c=j.call(arguments,2),d=function(){if(!(this instanceof d))return a.apply(b,c.concat(j.call(arguments)));G.prototype=a.prototype;var e=new G;G.prototype=null;var f=a.apply(e,c.concat(j.call(arguments)));return Object(f)===f?f:e}},z.partial=function(a){var b=j.call(arguments,1);return function(){return a.apply(this,b.concat(j.call(arguments)))}},z.bindAll=function(a){var b=j.call(arguments,1);if(0===b.length)throw new Error("bindAll must be passed function names");return A(b,function(b){a[b]=z.bind(a[b],a)}),a},z.memoize=function(a,b){var c={};return b||(b=z.identity),function(){var d=b.apply(this,arguments);return z.has(c,d)?c[d]:c[d]=a.apply(this,arguments)}},z.delay=function(a,b){var c=j.call(arguments,2);return setTimeout(function(){return a.apply(null,c)},b)},z.defer=function(a){return z.delay.apply(z,[a,1].concat(j.call(arguments,1)))},z.throttle=function(a,b,c){var d,e,f,g=null,h=0;c||(c={});var i=function(){h=c.leading===!1?0:new Date,g=null,f=a.apply(d,e)};return function(){var j=new Date;h||c.leading!==!1||(h=j);var k=b-(j-h);return d=this,e=arguments,k<=0?(clearTimeout(g),g=null,h=j,
+f=a.apply(d,e)):g||c.trailing===!1||(g=setTimeout(i,k)),f}},z.debounce=function(a,b,c){var d,e,f,g,h;return function(){f=this,e=arguments,g=new Date;var i=function(){var j=new Date-g;j<b?d=setTimeout(i,b-j):(d=null,c||(h=a.apply(f,e)))},j=c&&!d;return d||(d=setTimeout(i,b)),j&&(h=a.apply(f,e)),h}},z.once=function(a){var b,c=!1;return function(){return c?b:(c=!0,b=a.apply(this,arguments),a=null,b)}},z.wrap=function(a,b){return function(){var c=[a];return i.apply(c,arguments),b.apply(this,c)}},z.compose=function(){var a=arguments;return function(){for(var b=arguments,c=a.length-1;c>=0;c--)b=[a[c].apply(this,b)];return b[0]}},z.after=function(a,b){return function(){if(--a<1)return b.apply(this,arguments)}},z.keys=x||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var b=[];for(var c in a)z.has(a,c)&&b.push(c);return b},z.values=function(a){for(var b=z.keys(a),c=b.length,d=new Array(c),e=0;e<c;e++)d[e]=a[b[e]];return d},z.pairs=function(a){for(var b=z.keys(a),c=b.length,d=new Array(c),e=0;e<c;e++)d[e]=[b[e],a[b[e]]];return d},z.invert=function(a){for(var b={},c=z.keys(a),d=0,e=c.length;d<e;d++)b[a[c[d]]]=c[d];return b},z.functions=z.methods=function(a){var b=[];for(var c in a)z.isFunction(a[c])&&b.push(c);return b.sort()},z.extend=function(a){return A(j.call(arguments,1),function(b){if(b)for(var c in b)a[c]=b[c]}),a},z.pick=function(a){var b={};return A(k.apply(f,j.call(arguments,1)),function(c){c in a&&(b[c]=a[c])}),b},z.omit=function(a){var b={},c=k.apply(f,j.call(arguments,1));for(var d in a)z.contains(c,d)||(b[d]=a[d]);return b},z.defaults=function(a){return A(j.call(arguments,1),function(b){if(b)for(var c in b)void 0===a[c]&&(a[c]=b[c])}),a},z.clone=function(a){return z.isObject(a)?z.isArray(a)?a.slice():z.extend({},a):a},z.tap=function(a,b){return b(a),a};var H=function(a,b,c,d){if(a===b)return 0!==a||1/a==1/b;if(null==a||null==b)return a===b;a instanceof z&&(a=a._wrapped),b instanceof z&&(b=b._wrapped);var e=l.call(a);if(e!=l.call(b))return!1;switch(e){case"[object String]":return a==String(b);case"[object Number]":return a!=+a?b!=+b:0==a?1/a==1/b:a==+b;case"[object Date]":case"[object Boolean]":return+a==+b;case"[object RegExp]":return a.source==b.source&&a.global==b.global&&a.multiline==b.multiline&&a.ignoreCase==b.ignoreCase}if("object"!=typeof a||"object"!=typeof b)return!1;for(var f=c.length;f--;)if(c[f]==a)return d[f]==b;var g=a.constructor,h=b.constructor;if(g!==h&&!(z.isFunction(g)&&g instanceof g&&z.isFunction(h)&&h instanceof h))return!1;c.push(a),d.push(b);var i=0,j=!0;if("[object Array]"==e){if(i=a.length,j=i==b.length)for(;i--&&(j=H(a[i],b[i],c,d)););}else{for(var k in a)if(z.has(a,k)&&(i++,!(j=z.has(b,k)&&H(a[k],b[k],c,d))))break;if(j){for(k in b)if(z.has(b,k)&&!i--)break;j=!i}}return c.pop(),d.pop(),j};z.isEqual=function(a,b){return H(a,b,[],[])},z.isEmpty=function(a){if(null==a)return!0;if(z.isArray(a)||z.isString(a))return 0===a.length;for(var b in a)if(z.has(a,b))return!1;return!0},z.isElement=function(a){return!(!a||1!==a.nodeType)},z.isArray=w||function(a){return"[object Array]"==l.call(a)},z.isObject=function(a){return a===Object(a)},A(["Arguments","Function","String","Number","Date","RegExp"],function(a){z["is"+a]=function(b){return l.call(b)=="[object "+a+"]"}}),z.isArguments(arguments)||(z.isArguments=function(a){return!(!a||!z.has(a,"callee"))}),"function"!=typeof/./&&(z.isFunction=function(a){return"function"==typeof a}),z.isFinite=function(a){return isFinite(a)&&!isNaN(parseFloat(a))},z.isNaN=function(a){return z.isNumber(a)&&a!=+a},z.isBoolean=function(a){return a===!0||a===!1||"[object Boolean]"==l.call(a)},z.isNull=function(a){return null===a},z.isUndefined=function(a){return void 0===a},z.has=function(a,b){return m.call(a,b)},z.noConflict=function(){return a._=d,this},z.identity=function(a){return a},z.times=function(a,b,c){for(var d=Array(Math.max(0,a)),e=0;e<a;e++)d[e]=b.call(c,e);return d},z.random=function(a,b){return null==b&&(b=a,a=0),a+Math.floor(Math.random()*(b-a+1))};var I={escape:{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;"}};I.unescape=z.invert(I.escape);var J={escape:new RegExp("["+z.keys(I.escape).join("")+"]","g"),unescape:new RegExp("("+z.keys(I.unescape).join("|")+")","g")};z.each(["escape","unescape"],function(a){z[a]=function(b){return null==b?"":(""+b).replace(J[a],function(b){return I[a][b]})}}),z.result=function(a,b){if(null!=a){var c=a[b];return z.isFunction(c)?c.call(a):c}},z.mixin=function(a){A(z.functions(a),function(b){var c=z[b]=a[b];z.prototype[b]=function(){var a=[this._wrapped];return i.apply(a,arguments),M.call(this,c.apply(z,a))}})};var K=0;z.uniqueId=function(a){var b=++K+"";return a?a+b:b},z.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var L={"'":"'","\\":"\\","\r":"r","\n":"n","\t":"t","\u2028":"u2028","\u2029":"u2029"};z.template=function(a,b,c){var d;c=z.defaults({},c,z.templateSettings);var e=new RegExp([(c.escape||/(.)^/).source,(c.interpolate||/(.)^/).source,(c.evaluate||/(.)^/).source].join("|")+"|$","g"),f=0,g="__p+='";a.replace(e,function(b,c,d,e,h){return g+=a.slice(f,h).replace(/\\|'|\r|\n|\t|\u2028|\u2029/g,function(a){return"\\"+L[a]}),c&&(g+="'+\n((__t=("+c+"))==null?'':_.escape(__t))+\n'"),d&&(g+="'+\n((__t=("+d+"))==null?'':__t)+\n'"),e&&(g+="';\n"+e+"\n__p+='"),f=h+b.length,b}),g+="';\n",c.variable||(g="with(obj||{}){\n"+g+"}\n"),g="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+g+"return __p;\n";try{d=new Function(c.variable||"obj","_",g)}catch(a){throw a.source=g,a}if(b)return d(b,z);var h=function(a){return d.call(this,a,z)};return h.source="function("+(c.variable||"obj")+"){\n"+g+"}",h},z.chain=function(a){return z(a).chain()};var M=function(a){return this._chain?z(a).chain():a};z.mixin(z),A(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var b=f[a];z.prototype[a]=function(){var c=this._wrapped;return b.apply(c,arguments),"shift"!=a&&"splice"!=a||0!==c.length||delete c[0],M.call(this,c)}}),A(["concat","join","slice"],function(a){var b=f[a];z.prototype[a]=function(){return M.call(this,b.apply(this._wrapped,arguments))}}),z.extend(z.prototype,{chain:function(){return this._chain=!0,this},value:function(){return this._wrapped}})}).call(this)},{}]},{},[4]);
\ No newline at end of file
diff --git a/bower_components/fielddb-glosser/samples/latex/latex_tree_carrier_phrase.tex b/bower_components/fielddb-glosser/samples/latex/latex_tree_carrier_phrase.tex
new file mode 100644
index 0000000..ed312cd
--- /dev/null
+++ b/bower_components/fielddb-glosser/samples/latex/latex_tree_carrier_phrase.tex
@@ -0,0 +1,14 @@
+\documentclass[12pt]{article}
+\usepackage{fullpage}
+\usepackage{tipa}
+\usepackage{qtree}
+\usepackage{gb4e}
+\begin{document}
+
+\Tree [.{payta suwanayan monikita} [.payta pay ta ] [.{suwanayan monikita} [.suwanayan suwa [.nayan naya n ] ] [.monikita moniki ta ] ] ]
+
+\Tree [.{payta suwanayan monikita} [.payta pay ta ] [.{suwanayan monikita} [.suwanayan [.suvanaya suwa naya ] n ] [.monikita moniki ta ] ] ]
+
+
+
+\end{document}
diff --git a/bower_components/fielddb-glosser/samples/vanilla/index.html b/bower_components/fielddb-glosser/samples/vanilla/index.html
new file mode 100644
index 0000000..e0796d0
--- /dev/null
+++ b/bower_components/fielddb-glosser/samples/vanilla/index.html
@@ -0,0 +1,107 @@
+<!doctype html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="style.css">
+    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/topcoat/0.8.0/css/topcoat-desktop-dark.min.css">
+    <link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css">
+</head>
+
+<body class="dark">
+
+    <table>
+        <tr class="browser-controls" id="lexiconBrowserControls">
+            <td colspan="2">
+                <header>
+                    <h2 hidden>Lexicon Browser</h2>
+
+                    <p>Welcome to the Lexicon Browser. This interface can be used to either browse your lexicon, or clean your corpus while cleaning the lexicon. The Lexicon is automatically trained based on the data in your Corpus, it is more similar to a Mental Lexicon than a Word List or Dictionary. To view examples of the morpheme's usage, hover over any morpheme either in the Precedence Graph where it appears in the context of other morphemes, or in the more traditional list form which congains the Lexicon Nodes as cards below. In the Lexicon Node List you can double click on any card to view/edit the discussion/definition of the lexical item. Click on any text to edit it.</p>
+
+                    <label class="topcoat-label">
+                        Re-train:
+                    </label>
+                    <button id="refreshButton" class="topcoat-button--large fa fa-refresh"></button>
+
+
+                    <label class="topcoat-label">
+                        Auto save and Re-train on edits:
+                    </label>
+                    <label class="topcoat-switch">
+                        <input type="checkbox" id="autoSaveAndReTrain" class="topcoat-switch__input"/>
+                        <div class="topcoat-switch__toggle">
+                        </div>
+                    </label>
+
+
+                    <label class="topcoat-label">
+                        Precedence Graph:
+                    </label>
+                    <label class="topcoat-switch">
+                        <input type="checkbox" id="showGlosserAsGraph" checked class="topcoat-switch__input"/>
+                        <div class="topcoat-switch__toggle">
+                        </div>
+                    </label>
+
+                    <label class="topcoat-label">
+                        Lexicon Node List:
+                    </label>
+                    <label class="topcoat-switch">
+                        <input type="checkbox" id="showLexiconAsList" checked class="topcoat-switch__input"/>
+                        <div class="topcoat-switch__toggle">
+                        </div>
+                    </label>
+
+                    <label class="topcoat-label" title="This can help see the linear/template order of morphemes, rather than which morphemes are over-represented in the corpus.">
+                        Graph Word Boundaries:
+                    </label>
+                    <label class="topcoat-switch">
+                        <input type="checkbox" id="graphWordBoundaries" class="topcoat-switch__input"/>
+                        <div class="topcoat-switch__toggle">
+                        </div>
+                    </label>
+
+
+                    <label class="topcoat" title="Lexicon nodes below the threshold wont be shown">Confidence cut-off:</label>
+                    <label class="topcoat">
+                        <input id="lexiconConfidenceThreshold" type="range" min="1" max="10" value="3" class="topcoat-range"/>
+                    </label>
+
+                </header>
+            </div>
+        </td>
+    </tr>
+    <tr>
+        <td colspan="2">
+            <h2>glossersample-quechua</h2>
+            <div id="glosser"></div>
+            <div id="lexicon" class="lexicon">  
+            </div>
+        </td>
+    </tr>
+    <tr>
+        <td>
+            <h2>glossersample-cherokee</h2>
+            <div id="glosser2"></div>
+            <div id="lexicon2" class="lexicon"></div>
+        </td>
+        <td>
+            <h2>glossersample-inuktitut</h2>
+            <div id="glosser3"></div>
+            <div id="lexicon3" class="lexicon"></div>
+        </td>
+    </tr>
+    <tr>
+        <td colspan="2">
+            <textarea  hidden id="lexiconJSON" class="topcoat-textarea lexiconJSON"  placeholder="Lexicon data">
+            </textarea>
+        </div>
+    </td>
+</tr>
+</table>
+
+<script src="../../fielddb-glosser.js"></script>
+<script src="main.js"></script>
+
+</body>
+</html>
diff --git a/bower_components/fielddb-glosser/samples/vanilla/main.js b/bower_components/fielddb-glosser/samples/vanilla/main.js
new file mode 100644
index 0000000..88d2212
--- /dev/null
+++ b/bower_components/fielddb-glosser/samples/vanilla/main.js
@@ -0,0 +1,128 @@
+var loadExamples = function() {
+  var graphWordBoundaries = document.getElementById("graphWordBoundaries");
+  var showWordBoundaries;
+  if (graphWordBoundaries && graphWordBoundaries.checked) {
+    showWordBoundaries = true;
+  } else {
+    showWordBoundaries = false;
+  }
+
+  var rerenderIfWordBoundariesChange = [];
+  graphWordBoundaries.onchange = function() {
+    if (graphWordBoundaries && graphWordBoundaries.checked) {
+      showWordBoundaries = true;
+    } else {
+      showWordBoundaries = false;
+    }
+    for (var functionToCall = 0; functionToCall < rerenderIfWordBoundariesChange.length; functionToCall++) {
+      rerenderIfWordBoundariesChange[functionToCall]();
+    }
+  };
+
+  var url = "https://corpusdev.lingsync.org";
+  var firstdb = "glossersample-quechua";
+  var firstGlosser = new Glosser({
+    pouchname: firstdb,
+    localDocument: window.document
+  });
+  firstGlosser.downloadPrecedenceRules(firstdb, url + "/" + firstdb + "/_design/lexicon2.2.0/_view/morphemesPrecedenceContext?group=true", function(precedenceRelations) {
+    var utterance = firstGlosser.guessUtteranceFromMorphemes({
+      utterance: "",
+      morphemes: "Kicha-nay-wa-n punqo-ta",
+      allomorphs: "",
+      gloss: "open-DES-1OM-3SG door-ACC",
+      translation: "I feel like opening the door."
+    });
+    console.log(utterance);
+    var lexicon = LexiconFactory({
+      precedenceRelations: precedenceRelations,
+      dbname: firstdb,
+      element: document.getElementById("lexicon"),
+      dontConnectWordBoundaries: !showWordBoundaries,
+      localDOM: window.document,
+      url: url+ "/" + firstdb
+    });
+    lexicon.bindToView();
+    var renderFirstGraph = function() {
+      var glosserElement = document.getElementById("glosser");
+      glosserElement.innerHTML = "";
+      var confidenceThreshold = document.getElementById("lexiconConfidenceThreshold").value /10;
+      firstGlosser.visualizePrecedenceRelationsAsForceDirectedGraph(lexicon, glosserElement, !showWordBoundaries, confidenceThreshold);
+    };
+    rerenderIfWordBoundariesChange.push(renderFirstGraph);
+    renderFirstGraph();
+  });
+
+  var seconddb = "glossersample-cherokee";
+  var secondGlosser = new Glosser({
+    pouchname: seconddb,
+    localDocument: window.document
+  });
+  secondGlosser.downloadPrecedenceRules(seconddb, url + "/" + seconddb + "/_design/lexicon2.2.0/_view/morphemesPrecedenceContext?group=true", function(precedenceRelations) {
+    var lexicon = LexiconFactory({
+      precedenceRelations: precedenceRelations,
+      dbname: seconddb,
+      element: document.getElementById("lexicon2"),
+      dontConnectWordBoundaries: !showWordBoundaries,
+      localDOM: window.document,
+      url: url+ "/" + seconddb
+    });
+    lexicon.bindToView();
+
+    var renderSecondGraph = function() {
+      var glosserElement = document.getElementById("glosser2");
+      glosserElement.innerHTML = "";
+      var confidenceThreshold = document.getElementById("lexiconConfidenceThreshold").value /10;
+      secondGlosser.visualizePrecedenceRelationsAsForceDirectedGraph(lexicon, glosserElement, !showWordBoundaries, confidenceThreshold);
+    };
+    rerenderIfWordBoundariesChange.push(renderSecondGraph);
+    renderSecondGraph();
+  });
+
+  var thirddb = "glossersample-inuktitut";
+  var thirdGlosser = new Glosser({
+    pouchname: thirddb,
+    localDocument: window.document
+  });
+  thirdGlosser.downloadPrecedenceRules(thirddb, url + "/" + thirddb + "/_design/lexicon2.2.0/_view/morphemesPrecedenceContext?group=true&limit=1000", function(precedenceRelations) {
+    var lexicon = LexiconFactory({
+      precedenceRelations: precedenceRelations,
+      dbname: thirddb,
+      element: document.getElementById("lexicon3"),
+      dontConnectWordBoundaries: !showWordBoundaries,
+      localDOM: window.document
+    });
+    lexicon.bindToView();
+
+    var renderThirdGraph = function() {
+      var glosserElement = document.getElementById("glosser3");
+      glosserElement.innerHTML = "";
+      var confidenceThreshold = document.getElementById("lexiconConfidenceThreshold").value /10;
+      thirdGlosser.visualizePrecedenceRelationsAsForceDirectedGraph(lexicon, glosserElement, !showWordBoundaries, confidenceThreshold);
+    };
+    rerenderIfWordBoundariesChange.push(renderThirdGraph);
+    renderThirdGraph();
+  });
+
+};
+
+var refreshButton = document.getElementById("refreshButton");
+refreshButton.onclick = loadExamples;
+
+
+var showGlosserAsGraph = document.getElementById("showGlosserAsGraph");
+showGlosserAsGraph.onchange = function(){
+  document.getElementById("glosser").hidden = !showGlosserAsGraph.checked;
+  document.getElementById("glosser2").hidden = !showGlosserAsGraph.checked;
+  document.getElementById("glosser3").hidden = !showGlosserAsGraph.checked;
+};
+
+
+var showLexiconAsList = document.getElementById("showLexiconAsList");
+showLexiconAsList.onchange = function(){
+  document.getElementById("lexicon").hidden = !showLexiconAsList.checked;
+  document.getElementById("lexicon2").hidden = !showLexiconAsList.checked;
+  document.getElementById("lexicon3").hidden = !showLexiconAsList.checked;
+};
+
+loadExamples();
diff --git a/bower_components/fielddb-glosser/samples/vanilla/style.css b/bower_components/fielddb-glosser/samples/vanilla/style.css
new file mode 100644
index 0000000..d686153
--- /dev/null
+++ b/bower_components/fielddb-glosser/samples/vanilla/style.css
@@ -0,0 +1,167 @@
+table {
+  width: 100%;
+}
+
+td {
+  width: 50%;
+  border: 1px solid rgba(255,255,255,50);
+  border-radius: 5px;
+}
+
+tr {
+  vertical-align: top;
+}
+
+h2{
+  font-weight: 300 !important;
+}
+
+.lexicon ul{
+  list-style-type: none;
+  clear: both;
+  margin: auto;
+  /*border: 1px solid white !important;*/
+}
+
+.lexicon ul li {
+  float: left;
+  padding: 0.5em;
+  margin: 0.5em;
+  border:2px solid black !important;
+  border-top-left-radius: 10px;
+  border-top-right-radius: 10px;
+  width: 20em;
+  /* make scrollable and same size */
+  height: 10em !important;
+  overflow: auto !important;
+}
+
+.node_details_tooltip {
+  padding: 0.5em;
+  margin: 0.5em;
+  border:2px solid black !important;
+  border-radius: 10px;
+  width: 20em;
+  background-color: #ccc;
+  opacity: 0.8;
+}
+
+.lexiconJSON{
+  width: 100%;
+  resize: auto !important;
+  height: 20em;
+}
+
+.lexicon .discussion {
+ font-style: italic;
+ margin-right: 0.2em;
+}
+
+.lexicon .utteranceContext {
+ font-style: italic;
+}
+
+.lexicon .headword {
+  font-weight: bold;
+  padding-right: 0.2em;
+}
+
+.lexicon dl {
+ width: 100%;
+ overflow: hidden;
+}
+
+/*
+dd:nth-of-type(odd) {   background-color: #333}
+dl:nth-of-type(odd) {  background-color: #ccc }​*/
+
+
+.lexicon dt span{
+  padding: 0;
+  margin: 0;
+  float:left;
+  width:40%;
+  color: #ccc;
+}
+
+.lexicon dd span{
+  padding: 0;
+  margin: 0;
+  float:left;
+  width:55%;
+}
+
+.utterance {
+ color: #ccc;
+ background-color: #323245;
+}
+
+.morphemes {
+ color: #ccc;
+ background-color: #353535;
+}
+
+.gloss {
+ color: #ccfcfc;
+ background-color: #232323;
+}
+
+.confidence {
+ color: #999;
+ background-color: #454545;
+}
+
+[contenteditable="true"]:focus{
+  color: #000;
+  background-color: #fff;
+}
+
+/* D3 force directed graph */
+circle.node {
+	stroke: #fff;
+	stroke-width: 1.5px;
+}
+
+line.link {
+	stroke-opacity: .6;
+}
+
+
+.link {
+  fill: none;
+  stroke: #666;
+  stroke-width: 1.5px;
+}
+
+#licensing {
+  fill: green;
+}
+
+.link.licensing {
+  stroke: green;
+}
+
+.link.resolved {
+  stroke-dasharray: 0,2 1;
+}
+
+circle {
+  fill: #ccc;
+  stroke: #333;
+  stroke-width: 1.5px;
+}
+/*
+text {
+  color: #fff;
+  background-color: #333;
+  opacity: .5;
+  }*/
+
+  .distance2{
+    opacity: 0.2;
+  }
+
+
+  .distance3{
+    opacity: 0.1;
+  }
diff --git a/package.json b/package.json
index b9c1a70..9d7a018 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "lexicon-elasticsearch",
-  "version": "4.46.12",
+  "version": "5.7.13",
   "description": "a lexicon web service with analyzers for a few languages and an elasticsearch wrapper",
   "homepage": "https://github.com/FieldDB/FieldDB/issues/milestones?state=closed",
   "repository": {
diff --git a/start_service b/start_service
index 1ac7799..73444b1 100755
--- a/start_service
+++ b/start_service
@@ -1,5 +1,5 @@
 #!/bin/bash
-
+export NODE_TLS_REJECT_UNAUTHORIZED=0
 cd $FIELDDB_HOME/LexiconWebService
 
 forever \