Controllet cross browser big fix

Luigi Serra
1 parent 4963f51a
Showing 534 changed files with 10973 additions and 6512 deletions
bower_components/google-map/.bower.json
bower_components/google-map/LICENSE
bower_components/google-map/README.md
bower_components/google-map/bower.json
bower_components/google-map/demo/index.html
bower_components/google-map/google-map-directions.html
bower_components/google-map/google-map-marker.html
bower_components/google-map/google-map-search.html
bower_components/google-map/google-map.html
bower_components/google-map/index.html
bower_components/google-map/metadata.html
bower_components/hydrolysis/.bower.json
bower_components/hydrolysis/.editorconfig
bower_components/hydrolysis/.gitattributes
bower_components/hydrolysis/API.md
bower_components/hydrolysis/LICENSE
bower_components/hydrolysis/README.md
bower_components/hydrolysis/bower.json
bower_components/hydrolysis/hydrolysis-analyzer.html
bower_components/hydrolysis/hydrolysis.html
 {
   "name": "google-map",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Google Maps web components",
   "homepage": "https://googlewebcomponents.github.io/google-map",
   "main": [
@@ -36,11 +36,11 @@
     "web-component-tester": "*",
     "iron-component-page": "PolymerElements/iron-component-page#^1.0.2"
   },
-  "_release": "1.1.0",
+  "_release": "1.1.2",
   "_resolution": {
     "type": "version",
-    "tag": "1.1.0",
-    "commit": "c45ddfa8c48a67dda1b2237589edcd45bc3f7802"
+    "tag": "1.1.2",
+    "commit": "3567129ffac7df683346b5c9d8ad0c32e9213adb"
   },
   "_source": "git://github.com/GoogleWebComponents/google-map.git",
   "_target": "^1.0.0",
 {
   "name": "google-map",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Google Maps web components",
   "homepage": "https://googlewebcomponents.github.io/google-map",
   "main": [
@@ -42,8 +42,23 @@ child of `google-map`.
 </dom-module>
  
 <script>
-
 (function() {
+
+  function setupDragHandler_() {
+    if (this.draggable) {
+      this.dragHandler_ = google.maps.event.addListener(
+          this.marker, 'dragend', onDragEnd_.bind(this));
+    } else {
+      google.maps.event.removeListener(this.dragHandler_);
+      this.dragHandler_ = null;
+    }
+  }
+
+  function onDragEnd_(e, details, sender) {
+    this.latitude = e.latLng.lat();
+    this.longitude = e.latLng.lng();
+  }
+
   Polymer({
  
     is: 'google-map-marker',
@@ -53,45 +68,53 @@ child of `google-map`.
      * @param {google.maps.MouseEvent} event The mouse event.
      * @event google-map-marker-click
      */
+
     /**
      * Fired when the marker icon was double clicked. Requires the clickEvents attribute to be true.
      * @param {google.maps.MouseEvent} event The mouse event.
      * @event google-map-marker-dblclick
      */
+
     /**
      * Fired for a mousedown on the marker. Requires the mouseEvents attribute to be true.
      * @event google-map-marker-mousedown
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     /**
      * Fired when the DOM `mousemove` event is fired on the marker. Requires the mouseEvents
      * attribute to be true.
      * @event google-map-marker-mousemove
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     /**
      * Fired when the mouse leaves the area of the marker icon. Requires the mouseEvents attribute to be
      * true.
      * @event google-map-marker-mouseout
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     /**
      * Fired when the mouse enters the area of the marker icon. Requires the mouseEvents attribute to be
      * true.
      * @event google-map-marker-mouseover
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     /**
      * Fired for a mouseup on the marker. Requires the mouseEvents attribute to be true.
      *
      * @event google-map-marker-mouseup
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     /**
      * Fired for a rightclick on the marker. Requires the clickEvents attribute to be true.
      * @event google-map-marker-rightclick
      * @param {google.maps.MouseEvent} event The mouse event.
      */
+
     properties: {
       /**
        * A Google Maps marker object.
@@ -161,6 +184,7 @@ child of `google-map`.
         value: null,
         reflectToAttribute: true
       },
+
       /**
        * The marker's latitude coordinate.
        */
@@ -168,6 +192,16 @@ child of `google-map`.
         type: Number,
         value: null,
         reflectToAttribute: true
+      },
+
+      /**
+       * A animation for the marker. "DROP" or "BOUNCE". See
+       * https://developers.google.com/maps/documentation/javascript/examples/marker-animations.
+       */
+      animation: {
+        type: String,
+        value: null,
+        observer: '_animationChanged'
       }
     },
  
@@ -231,6 +265,12 @@ child of `google-map`.
       }
     },
  
+    _animationChanged: function() {
+      if (this.marker) {
+        this.marker.setAnimation(google.maps.Animation[this.animation]);
+      }
+    },
+
     _iconChanged: function() {
       if (this.marker) {
         this.marker.setIcon(this.icon);
@@ -288,8 +328,12 @@ child of `google-map`.
       this._listeners = {};
       this.marker = new google.maps.Marker({
         map: this.map,
-        position: {lat: this.latitude, lng: this.longitude},
+        position: {
+          lat: parseFloat(this.latitude),
+          lng: parseFloat(this.longitude)
+        },
         title: this.title,
+        animation: google.maps.Animation[this.animation],
         draggable: this.draggable,
         visible: !this.hidden,
         icon: this.icon,
@@ -336,19 +380,5 @@ child of `google-map`.
     }
   });
  
-  function setupDragHandler_() {
-    if (this.draggable) {
-      this.dragHandler_ = google.maps.event.addListener(
-          this.marker, 'dragend', onDragEnd_.bind(this));
-    } else {
-      google.maps.event.removeListener(this.dragHandler_);
-      this.dragHandler_ = null;
-    }
-  }
-
-  function onDragEnd_(e, details, sender) {
-    this.latitude = e.latLng.lat();
-    this.longitude = e.latLng.lng();
-  }
 })();
 </script>
@@ -11,7 +11,7 @@ information on the API.
 #### Example:
  
     <template is="dom-bind">
-      <google-map-search map="[[map]]" query="Pizza"
+      <google-map-search map="[[map]]" libraries="places" query="Pizza"
                          results="{{results}}"></google-map-search>
       <google-map map="{{map}}" latitude="37.779"
                   longitude="-122.3892">
@@ -119,7 +119,7 @@ information on the API.
       location: {
         type: Object,
         value: null,
-        readyOnly: true
+        readOnly: true
       }
     },
  
@@ -129,6 +129,13 @@ information on the API.
     ],
  
     /**
+     * Fired when the details of a place are returned.
+     *
+     * @event google-map-search-place-detail
+     *   @param {google.maps.MarkerPlace} detail The place details.
+     */
+
+    /**
      * Fired when the search element returns a result.
      *
      * @event google-map-search-results
@@ -166,6 +173,26 @@ information on the API.
       }
     },
  
+    /**
+     * Fetches details for a given place.
+     * @param {String} placeId The place id.
+     * @return {Promise} place The place information.
+     */
+    getDetails: function(placeId) {
+      var places = new google.maps.places.PlacesService(this.map);
+
+      return new Promise(function(resolve, reject) {
+        places.getDetails({placeId: placeId}, function(place, status) {
+          if (status === google.maps.places.PlacesServiceStatus.OK) {
+            resolve(place);
+            this.fire('google-map-search-place-detail', place);
+          } else {
+            reject(status);
+          }
+        }.bind(this));
+      }.bind(this));
+    },
+
     _gotResults: function(results, status) {
       this.results = results.map(function(result) {
         // obtain lat/long from geometry
@@ -204,7 +204,8 @@ The `google-map` element renders a Google Map.
       zoom: {
         type: Number,
         value: 10,
-        observer: '_zoomChanged'
+        observer: '_zoomChanged',
+        notify: true
       },
  
       /**
@@ -221,7 +222,8 @@ The `google-map` element renders a Google Map.
       mapType: {
         type: String,
         value: 'roadmap', // roadmap, satellite, hybrid, terrain,
-        observer: '_mapTypeChanged'
+        observer: '_mapTypeChanged',
+        notify: true
       },
  
       /**
@@ -671,6 +673,10 @@ The `google-map` element renders a Google Map.
       google.maps.event.addListener(this.map, 'zoom_changed', function() {
         this.zoom = this.map.getZoom();
       }.bind(this));
+      
+      google.maps.event.addListener(this.map, 'maptypeid_changed', function() {
+        this.mapType = this.map.getMapTypeId();
+      }.bind(this));
  
       this._clickEventsChanged();
       this._dragEventsChanged();
@@ -19,13 +19,13 @@
     "webcomponentsjs": "webcomponents/webcomponentsjs#^0.7.0",
     "web-component-tester": "*"
   },
-  "version": "1.15.2",
+  "version": "1.19.0",
   "homepage": "https://github.com/Polymer/hydrolysis",
-  "_release": "1.15.2",
+  "_release": "1.19.0",
   "_resolution": {
     "type": "version",
-    "tag": "v1.15.2",
-    "commit": "3b255182fd39a273c255ac2a49db8d06d96f667d"
+    "tag": "v1.19.0",
+    "commit": "8b0e8410712cc465a35b854ce86bfb6b23e2e9ab"
   },
   "_source": "git://github.com/Polymer/hydrolysis.git",
   "_target": "^1.11",
@@ -24,31 +24,38 @@ Static analysis for Polymer.
   * [.Analyzer](#hydrolysis.Analyzer)
     * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
     * _instance_
-      * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
-      * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
-      * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
-      * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
-      * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
-      * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
-      * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
-      * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
-      * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
-      * [.annotate()](#hydrolysis.Analyzer#annotate)
-      * [.clean()](#hydrolysis.Analyzer#clean)
+      * [.elements](#hydrolysis.Analyzer+elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
+      * [.elementsByTagName](#hydrolysis.Analyzer+elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
+      * [.features](#hydrolysis.Analyzer+features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
+      * [.behaviors](#hydrolysis.Analyzer+behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
+      * [.behaviorsByName](#hydrolysis.Analyzer+behaviorsByName) : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
+      * [.html](#hydrolysis.Analyzer+html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
+      * [.parsedDocuments](#hydrolysis.Analyzer+parsedDocuments) : <code>Object</code>
+      * [.parsedScripts](#hydrolysis.Analyzer+parsedScripts) : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
+      * [._content](#hydrolysis.Analyzer+_content) : <code>Object</code>
+      * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer+_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
+      * [.metadataTree(href)](#hydrolysis.Analyzer+metadataTree) ⇒ <code>Promise</code>
+      * [.getLoadedAst(href, [loaded])](#hydrolysis.Analyzer+getLoadedAst) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
+      * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkDocuments) ⇒ <code>Object</code>
+      * [.nodeWalkAllDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkAllDocuments) ⇒ <code>Object</code>
+      * [.annotate()](#hydrolysis.Analyzer+annotate)
+      * [.clean()](#hydrolysis.Analyzer+clean)
     * _static_
       * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
   * [.FileLoader](#hydrolysis.FileLoader)
     * [new FileLoader()](#new_hydrolysis.FileLoader_new)
-    * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
-    * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
+    * [.addResolver(resolver)](#hydrolysis.FileLoader+addResolver)
+    * [.request(url)](#hydrolysis.FileLoader+request) ⇒ <code>Promise.&lt;string&gt;</code>
   * [.FSResolver](#hydrolysis.FSResolver)
     * [new FSResolver(config)](#new_hydrolysis.FSResolver_new)
   * [.NoopResolver](#hydrolysis.NoopResolver)
     * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
-    * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
+    * [.accept(uri, deferred)](#hydrolysis.NoopResolver+accept) ⇒ <code>boolean</code>
   * [.XHRResolver](#hydrolysis.XHRResolver)
     * [new XHRResolver(config)](#new_hydrolysis.XHRResolver_new)
   * [.DocumentAST](#hydrolysis.DocumentAST) : <code>Object</code>
+  * [.JSAST](#hydrolysis.JSAST) : <code>Object</code>
+  * [.ParsedJS](#hydrolysis.ParsedJS) : <code>Object</code>
   * [.ElementDescriptor](#hydrolysis.ElementDescriptor) : <code>Object</code>
   * [.FeatureDescriptor](#hydrolysis.FeatureDescriptor) : <code>Object</code>
   * [.BehaviorDescriptor](#hydrolysis.BehaviorDescriptor) : <code>Object</code>
@@ -64,17 +71,22 @@ Static analysis for Polymer.
 * [.Analyzer](#hydrolysis.Analyzer)
   * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
   * _instance_
-    * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
-    * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
-    * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
-    * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
-    * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
-    * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
-    * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
-    * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
-    * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
-    * [.annotate()](#hydrolysis.Analyzer#annotate)
-    * [.clean()](#hydrolysis.Analyzer#clean)
+    * [.elements](#hydrolysis.Analyzer+elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
+    * [.elementsByTagName](#hydrolysis.Analyzer+elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
+    * [.features](#hydrolysis.Analyzer+features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
+    * [.behaviors](#hydrolysis.Analyzer+behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
+    * [.behaviorsByName](#hydrolysis.Analyzer+behaviorsByName) : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
+    * [.html](#hydrolysis.Analyzer+html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
+    * [.parsedDocuments](#hydrolysis.Analyzer+parsedDocuments) : <code>Object</code>
+    * [.parsedScripts](#hydrolysis.Analyzer+parsedScripts) : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
+    * [._content](#hydrolysis.Analyzer+_content) : <code>Object</code>
+    * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer+_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
+    * [.metadataTree(href)](#hydrolysis.Analyzer+metadataTree) ⇒ <code>Promise</code>
+    * [.getLoadedAst(href, [loaded])](#hydrolysis.Analyzer+getLoadedAst) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
+    * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkDocuments) ⇒ <code>Object</code>
+    * [.nodeWalkAllDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkAllDocuments) ⇒ <code>Object</code>
+    * [.annotate()](#hydrolysis.Analyzer+annotate)
+    * [.clean()](#hydrolysis.Analyzer+clean)
   * _static_
     * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
  
@@ -88,38 +100,55 @@ A database of Polymer metadata defined in HTML
 | attachAST | <code>boolean</code> | If true, attach a parse5 compliant AST |
 | [loader] | <code>FileLoader</code> | An optional `FileLoader` used to load external                              resources |
  
-<a name="hydrolysis.Analyzer#elements"></a>
+<a name="hydrolysis.Analyzer+elements"></a>
 #### analyzer.elements : <code>Array.&lt;ElementDescriptor&gt;</code>
 A list of all elements the `Analyzer` has metadata for.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#elementsByTagName"></a>
+<a name="hydrolysis.Analyzer+elementsByTagName"></a>
 #### analyzer.elementsByTagName : <code>Object.&lt;string, ElementDescriptor&gt;</code>
 A view into `elements`, keyed by tag name.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#features"></a>
+<a name="hydrolysis.Analyzer+features"></a>
 #### analyzer.features : <code>Array.&lt;FeatureDescriptor&gt;</code>
 A list of API features added to `Polymer.Base` encountered by the
 analyzer.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#behaviors"></a>
+<a name="hydrolysis.Analyzer+behaviors"></a>
 #### analyzer.behaviors : <code>Array.&lt;BehaviorDescriptor&gt;</code>
 The behaviors collected by the analysis pass.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#html"></a>
+<a name="hydrolysis.Analyzer+behaviorsByName"></a>
+#### analyzer.behaviorsByName : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
+The behaviors collected by the analysis pass by name.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer+html"></a>
 #### analyzer.html : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
 A map, keyed by absolute path, of Document metadata.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#parsedDocuments"></a>
+<a name="hydrolysis.Analyzer+parsedDocuments"></a>
 #### analyzer.parsedDocuments : <code>Object</code>
 A map, keyed by path, of HTML document ASTs.
  
 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#_getDependencies"></a>
+<a name="hydrolysis.Analyzer+parsedScripts"></a>
+#### analyzer.parsedScripts : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
+A map, keyed by path, of JS script ASTs.
+
+If the path is an HTML file with multiple scripts, the entry will be an array of scripts.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer+_content"></a>
+#### analyzer._content : <code>Object</code>
+A map, keyed by path, of document content.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer+_getDependencies"></a>
 #### analyzer._getDependencies(href, [found], [transitive]) ⇒ <code>Array.&lt;string&gt;</code>
 List all the html dependencies for the document at `href`.
  
@@ -132,7 +161,7 @@ List all the html dependencies for the document at `href`.
 | [found] | <code>Object.&lt;string, boolean&gt;</code> | An object keyed by URL of the     already resolved dependencies. |
 | [transitive] | <code>boolean</code> | Whether to load transitive     dependencies. Defaults to true. |
  
-<a name="hydrolysis.Analyzer#metadataTree"></a>
+<a name="hydrolysis.Analyzer+metadataTree"></a>
 #### analyzer.metadataTree(href) ⇒ <code>Promise</code>
 Returns a promise that resolves to a POJO representation of the import
 tree, in a format that maintains the ordering of the HTML imports spec.
@@ -143,9 +172,35 @@ tree, in a format that maintains the ordering of the HTML imports spec.
 | --- | --- | --- |
 | href | <code>string</code> | the import to get metadata for. |
  
-<a name="hydrolysis.Analyzer#nodeWalkDocuments"></a>
+<a name="hydrolysis.Analyzer+getLoadedAst"></a>
+#### analyzer.getLoadedAst(href, [loaded]) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
+Returns a promise resolving to a form of the AST with all links replaced
+with the document they link to. .css and .script files become &lt;style&gt; and
+&lt;script&gt;, respectively.
+
+The elements in the loaded document are unmodified from their original
+documents.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| href | <code>string</code> | The document to load. |
+| [loaded] | <code>Object.&lt;string, boolean&gt;</code> | An object keyed by already loaded documents. |
+
+<a name="hydrolysis.Analyzer+nodeWalkDocuments"></a>
 #### analyzer.nodeWalkDocuments(predicate) ⇒ <code>Object</code>
-Calls `dom5.nodeWalk` on each document that `Anayzler` has laoded.
+Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| predicate | <code>Object</code> | A dom5 predicate. |
+
+<a name="hydrolysis.Analyzer+nodeWalkAllDocuments"></a>
+#### analyzer.nodeWalkAllDocuments(predicate) ⇒ <code>Object</code>
+Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.
  
 **Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
  
@@ -153,12 +208,12 @@ Calls `dom5.nodeWalk` on each document that `Anayzler` has laoded.
 | --- | --- | --- |
 | predicate | <code>Object</code> | A dom5 predicate. |
  
-<a name="hydrolysis.Analyzer#annotate"></a>
+<a name="hydrolysis.Analyzer+annotate"></a>
 #### analyzer.annotate()
 Annotates all loaded metadata with its documentation.
  
 **Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
-<a name="hydrolysis.Analyzer#clean"></a>
+<a name="hydrolysis.Analyzer+clean"></a>
 #### analyzer.clean()
 Removes redundant properties from the collected descriptors.
  
@@ -185,14 +240,14 @@ In order to properly filter paths, `href` _must_ be an absolute URI.
  
 * [.FileLoader](#hydrolysis.FileLoader)
   * [new FileLoader()](#new_hydrolysis.FileLoader_new)
-  * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
-  * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
+  * [.addResolver(resolver)](#hydrolysis.FileLoader+addResolver)
+  * [.request(url)](#hydrolysis.FileLoader+request) ⇒ <code>Promise.&lt;string&gt;</code>
  
 <a name="new_hydrolysis.FileLoader_new"></a>
 #### new FileLoader()
 A FileLoader lets you resolve URLs with a set of potential resolvers.
  
-<a name="hydrolysis.FileLoader#addResolver"></a>
+<a name="hydrolysis.FileLoader+addResolver"></a>
 #### fileLoader.addResolver(resolver)
 Add an instance of a Resolver class to the list of url resolvers
  
@@ -205,7 +260,7 @@ The first resolver to &quot;accept&quot; the url wins.
 | --- | --- | --- |
 | resolver | <code>Resolver</code> | The resolver to add. |
  
-<a name="hydrolysis.FileLoader#request"></a>
+<a name="hydrolysis.FileLoader+request"></a>
 #### fileLoader.request(url) ⇒ <code>Promise.&lt;string&gt;</code>
 Return a promise for an absolute url
  
@@ -241,7 +296,7 @@ Resolves requests via the file system.
  
 * [.NoopResolver](#hydrolysis.NoopResolver)
   * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
-  * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
+  * [.accept(uri, deferred)](#hydrolysis.NoopResolver+accept) ⇒ <code>boolean</code>
  
 <a name="new_hydrolysis.NoopResolver_new"></a>
 #### new NoopResolver(config)
@@ -252,7 +307,7 @@ A resolver that resolves to null any uri matching config.
 | --- | --- | --- |
 | config | <code>string</code> | The url to `accept`. |
  
-<a name="hydrolysis.NoopResolver#accept"></a>
+<a name="hydrolysis.NoopResolver+accept"></a>
 #### noopResolver.accept(uri, deferred) ⇒ <code>boolean</code>
 **Kind**: instance method of <code>[NoopResolver](#hydrolysis.NoopResolver)</code>  
 **Returns**: <code>boolean</code> - Whether the URI is handled by this resolver.  
@@ -280,6 +335,23 @@ Construct a resolver that requests resources over XHR.
 Parse5's representation of a parsed html document
  
 **Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.JSAST"></a>
+### hydrolysis.JSAST : <code>Object</code>
+espree's representation of a parsed html document
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.ParsedJS"></a>
+### hydrolysis.ParsedJS : <code>Object</code>
+Package of a parsed JS script
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| ast | <code>JSAST</code> | The script's AST |
+| scriptElement | <code>DocumentAST</code> | If inline, the script's containing tag. |
+
 <a name="hydrolysis.ElementDescriptor"></a>
 ### hydrolysis.ElementDescriptor : <code>Object</code>
 The metadata for a single polymer element
 # hydrolysis
  
-Static anlaysis utilities for polymer.
+Static analysis utilities for polymer.
  
 ## Install
 ```
@@ -19,5 +19,5 @@
     "webcomponentsjs": "webcomponents/webcomponentsjs#^0.7.0",
     "web-component-tester": "*"
   },
-  "version": "1.15.1"
+  "version": "1.19.0"
 }
@@ -13,7 +13,6 @@ require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof requ
 'use strict';
 // jshint -W079
 var Promise = global.Promise || require('es6-promise').Promise;
-require("setimmediate");
 // jshint +W079
  
 var dom5 = require('dom5');
@@ -42,6 +41,20 @@ var EMPTY_METADATA = {elements: [], features: [], behaviors: []};
  */
  
 /**
+ * espree's representation of a parsed html document
+ * @typedef {Object} JSAST
+ * @memberof hydrolysis
+ */
+
+/**
+ * Package of a parsed JS script
+ * @typedef {Object} ParsedJS
+ * @property {JSAST} ast The script's AST
+ * @property {DocumentAST} scriptElement If inline, the script's containing tag.
+ * @memberof hydrolysis
+ */
+
+/**
  * The metadata for a single polymer element
  * @typedef {Object} ElementDescriptor
  * @memberof hydrolysis
@@ -125,13 +138,18 @@ var Analyzer = function Analyzer(attachAST,
   this.behaviors = [];
  
   /**
+   * The behaviors collected by the analysis pass by name.
+   *
+   * @member {Object<string,BehaviorDescriptor>}
+   */
+  this.behaviorsByName = {};
+
+  /**
    * A map, keyed by absolute path, of Document metadata.
    * @member {Object<string,AnalyzedDocument>}
    */
   this.html = {};
  
-  this._parsedDocuments = {};
-  
   /**
    * A map, keyed by path, of HTML document ASTs.
    * @type {Object}
@@ -139,6 +157,17 @@ var Analyzer = function Analyzer(attachAST,
   this.parsedDocuments = {};
  
   /**
+   * A map, keyed by path, of JS script ASTs.
+   *
+   * If the path is an HTML file with multiple scripts, the entry will be an array of scripts.
+   *
+   * @type {Object<string,Array<ParsedJS>>}
+   */
+  this.parsedScripts = {};
+
+  
+
+  /**
    * A map, keyed by path, of document content.
    * @type {Object}
    */
@@ -207,11 +236,14 @@ function _defaultFilter(href) {
 Analyzer.prototype.load = function load(href) {
   return this.loader.request(href).then(function(content) {
     return new Promise(function(resolve, reject) {
-      setImmediate(function() {
+      setTimeout(function() {
         this._content[href] = content;
         resolve(this._parseHTML(content, href));
-      }.bind(this));
-    }.bind(this));
+      }.bind(this), 0);
+    }.bind(this)).catch(function(err){
+      console.error("Error processing document at " + href);
+      throw err;
+    });
   }.bind(this));
 };
  
@@ -240,8 +272,26 @@ Analyzer.prototype._parseHTML = function _parseHTML(htmlImport,
   var htmlLoaded = Promise.resolve(parsed);
   if (parsed.script) {
     metadataLoaded = this._processScripts(parsed.script, href);
-    depsLoaded.push(metadataLoaded);
   }
+  var commentText = parsed.comment.map(function(comment){
+    return dom5.getTextContent(comment);
+  });
+  var pseudoElements = docs.parsePseudoElements(commentText);
+  pseudoElements.forEach(function(element){
+    element.contentHref = href;
+    this.elements.push(element);
+    this.elementsByTagName[element.is] = element;
+  }.bind(this));
+  metadataLoaded = metadataLoaded.then(function(metadata){
+    var metadataEntry = {
+      elements: pseudoElements,
+      features: [],
+      behaviors: []
+    };
+    return [metadata, metadataEntry].reduce(reduceMetadata);
+  });
+  depsLoaded.push(metadataLoaded);
+
  
   if (this.loader) {
     var baseUri = href;
@@ -278,7 +328,6 @@ Analyzer.prototype._parseHTML = function _parseHTML(htmlImport,
   depsLoaded = Promise.all(depsLoaded)
         .then(function() {return depHrefs;})
         .catch(function(err) {throw err;});
-  this._parsedDocuments[href] = parsed;
   this.parsedDocuments[href] = parsed.ast;
   this.html[href] = {
       href: href,
@@ -305,7 +354,7 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
   var parsedJs;
   if (!src) {
     try {
-      parsedJs = jsParse(script.childNodes[0].value);
+      parsedJs = jsParse((script.childNodes.length) ? script.childNodes[0].value : '');
     } catch (err) {
       // Figure out the correct line number for the error.
       var line = 0;
@@ -318,7 +367,7 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
       col += err.column;
       var message = "Error parsing script in " + href + " at " + line + ":" + col;
       message += "\n" + err.description;
-      throw new Error(message);
+      return Promise.reject(new Error(message));
     }
     if (parsedJs.elements) {
       parsedJs.elements.forEach(function(element) {
@@ -342,9 +391,22 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
     if (parsedJs.behaviors) {
       parsedJs.behaviors.forEach(function(behavior){
         behavior.contentHref = href;
-      });
+        this.behaviorsByName[behavior.is] = behavior;
+        this.behaviorsByName[behavior.symbol] = behavior;
+      }.bind(this));
       this.behaviors = this.behaviors.concat(parsedJs.behaviors);
     }
+    if (!Object.hasOwnProperty.call(this.parsedScripts, href)) {
+      this.parsedScripts[href] = [];
+    }
+    var scriptElement;
+    if (script.__ownerDocument && script.__ownerDocument == href) {
+      scriptElement = script;
+    }
+    this.parsedScripts[href].push({
+      ast: parsedJs.parsedScript,
+      scriptElement: scriptElement
+    });
     return parsedJs;
   }
   if (this.loader) {
@@ -417,6 +479,38 @@ Analyzer.prototype._getDependencies = function _getDependencies(href, found, tra
   });
 };
  
+function matchesDocumentFolder(descriptor, href) {
+  if (!descriptor.contentHref) {
+    return false;
+  }
+  var descriptorDoc = url.parse(descriptor.contentHref);
+  if (!descriptorDoc || !descriptorDoc.pathname) {
+    return false;
+  }
+  var searchDoc = url.parse(href);
+  if (!searchDoc || !searchDoc.pathname) {
+    return false;
+  }
+  var searchPath = searchDoc.pathname;
+  var lastSlash = searchPath.lastIndexOf("/");
+  if (lastSlash > 0) {
+    searchPath = searchPath.slice(0, lastSlash);
+  }
+  return descriptorDoc.pathname.indexOf(searchPath) === 0;
+}
+
+Analyzer.prototype.elementsForFolder = function elementsForFolder(href) {
+  return this.elements.filter(function(element){
+    return matchesDocumentFolder(element, href);
+  });
+};
+
+Analyzer.prototype.behaviorsForFolder = function behaviorsForFolder(href) {
+  return this.behaviors.filter(function(behavior){
+    return matchesDocumentFolder(behavior, href);
+  });
+};
+
 /**
  * Returns a promise that resolves to a POJO representation of the import
  * tree, in a format that maintains the ordering of the HTML imports spec.
@@ -545,12 +639,12 @@ Analyzer.prototype._inlineImports = function _inlineImports(ast, href, loaded) {
  
 /**
  * Returns a promise resolving to a form of the AST with all links replaced
- * with the document they link to. .css and .script files become <style> and
- * <script>, respectively.
+ * with the document they link to. .css and .script files become &lt;style&gt; and
+ * &lt;script&gt;, respectively.
  *
  * The elements in the loaded document are unmodified from their original
  * documents.
- * 
+ *
  * @param {string} href The document to load.
  * @param {Object.<string,boolean>=} loaded An object keyed by already loaded documents.
  * @return {Promise.<DocumentAST>}
@@ -560,9 +654,9 @@ Analyzer.prototype.getLoadedAst = function getLoadedAst(href, loaded) {
     loaded = {};
   }
   loaded[href] = true;
-  var document = this._parsedDocuments[href];
+  var parsedDocument = this.parsedDocuments[href];
   var analyzedDocument = this.html[href];
-  var astCopy = dom5.parse(dom5.serialize(document.ast));
+  var astCopy = dom5.parse(dom5.serialize(parsedDocument));
   // Whenever we inline something, reset inlined to true to know that anoather
   // inlining pass is needed;
   this._inlineStyles(astCopy, href);
@@ -577,8 +671,8 @@ Analyzer.prototype.getLoadedAst = function getLoadedAst(href, loaded) {
  * @return {Object}
  */
 Analyzer.prototype.nodeWalkDocuments = function nodeWalkDocuments(predicate) {
-  for (var href in this._parsedDocuments) {
-    var match = dom5.nodeWalk(this._parsedDocuments[href].ast, predicate);
+  for (var href in this.parsedDocuments) {
+    var match = dom5.nodeWalk(this.parsedDocuments[href], predicate);
     if (match) {
       return match;
     }
@@ -593,8 +687,8 @@ Analyzer.prototype.nodeWalkDocuments = function nodeWalkDocuments(predicate) {
  */
 Analyzer.prototype.nodeWalkAllDocuments = function nodeWalkDocuments(predicate) {
   var results = [];
-  for (var href in this._parsedDocuments) {
-    var newNodes = dom5.nodeWalkAll(this._parsedDocuments[href].ast, predicate);
+  for (var href in this.parsedDocuments) {
+    var newNodes = dom5.nodeWalkAll(this.parsedDocuments[href], predicate);
     results = results.concat(newNodes);
   }
   return results;
@@ -607,9 +701,17 @@ Analyzer.prototype.annotate = function annotate() {
     this.elements.unshift(featureEl);
     this.elementsByTagName[featureEl.is] = featureEl;
   }
-
-  this.elements.forEach(docs.annotateElement);
-  this.behaviors.forEach(docs.annotateElement); // Same shape.
+  var behaviorsByName = this.behaviorsByName;
+  var elementHelper = function(descriptor){
+    docs.annotateElement(descriptor, behaviorsByName);
+  };
+  this.elements.forEach(elementHelper);
+  this.behaviors.forEach(elementHelper); // Same shape.
+  this.behaviors.forEach(function(behavior){
+    if (behavior.is !== behavior.symbol && behavior.symbol) {
+      this.behaviorsByName[behavior.symbol] = undefined;
+    }
+  }.bind(this));
 };
  
 function attachDomModule(parsedImport, element) {
@@ -631,8 +733,8 @@ Analyzer.prototype.clean = function clean() {
 module.exports = Analyzer;
  
 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
-},{"./ast-utils/docs":5,"./ast-utils/import-parse":10,"./ast-utils/js-parse":11,"./loader/file-loader":13,"./loader/fs-resolver":14,"./loader/noop-resolver":15,"./loader/xhr-resolver":16,"dom5":38,"es6-promise":60,"setimmediate":74,"url":26}],2:[function(require,module,exports){
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["lib/analyzer.js"],"names":[],"mappings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file":"generated.js","sourceRoot":"","sourcesContent":["/**\n * @license\n * Copyright (c) 2015 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n// jshint node: true\n'use strict';\n// jshint -W079\nvar Promise = global.Promise || require('es6-promise').Promise;\n// jshint +W079\n\nvar dom5 = require('dom5');\nvar url = require('url');\n\nvar docs = require('./ast-utils/docs');\nvar FileLoader = require('./loader/file-loader');\nvar importParse = require('./ast-utils/import-parse');\nvar jsParse = require('./ast-utils/js-parse');\nvar NoopResolver = require('./loader/noop-resolver');\n\nfunction reduceMetadata(m1, m2) {\n  return {\n    elements:  m1.elements.concat(m2.elements),\n    features:  m1.features.concat(m2.features),\n    behaviors: m1.behaviors.concat(m2.behaviors),\n  };\n}\n\nvar EMPTY_METADATA = {elements: [], features: [], behaviors: []};\n\n/**\n * Parse5's representation of a parsed html document\n * @typedef {Object} DocumentAST\n * @memberof hydrolysis\n */\n\n/**\n * espree's representation of a parsed html document\n * @typedef {Object} JSAST\n * @memberof hydrolysis\n */\n\n/**\n * Package of a parsed JS script\n * @typedef {Object} ParsedJS\n * @property {JSAST} ast The script's AST\n * @property {DocumentAST} scriptElement If inline, the script's containing tag.\n * @memberof hydrolysis\n */\n\n/**\n * The metadata for a single polymer element\n * @typedef {Object} ElementDescriptor\n * @memberof hydrolysis\n */\n\n/**\n * The metadata for a Polymer feature.\n * @typedef {Object} FeatureDescriptor\n * @memberof hydrolysis\n */\n\n/**\n * The metadata for a Polymer behavior mixin.\n * @typedef {Object} BehaviorDescriptor\n * @memberof hydrolysis\n */\n\n/**\n * The metadata for all features and elements defined in one document\n * @typedef {Object} DocumentDescriptor\n * @memberof hydrolysis\n * @property {Array<ElementDescriptor>} elements The elements from the document\n * @property {Array<FeatureDescriptor>}  features The features from the document\n * @property {Array<FeatureDescriptor>}  behaviors The behaviors from the document\n */\n\n/**\n * The metadata of an entire HTML document, in promises.\n * @typedef {Object} AnalyzedDocument\n * @memberof hydrolysis\n * @property {string} href The url of the document.\n * @property {Promise<ParsedImport>}  htmlLoaded The parsed representation of\n *     the doc. Use the `ast` property to get the full `parse5` ast\n *\n * @property {Promise<Array<string>>} depsLoaded Resolves to the list of this\n *     Document's transitive import dependencies\n *\n * @property {Array<string>} depHrefs The direct dependencies of the document.\n *\n * @property {Promise<DocumentDescriptor>} metadataLoaded Resolves to the list of\n *     this Document's import dependencies\n */\n\n/**\n * A database of Polymer metadata defined in HTML\n *\n * @constructor\n * @memberOf hydrolysis\n * @param  {boolean} attachAST  If true, attach a parse5 compliant AST\n * @param  {FileLoader=} loader An optional `FileLoader` used to load external\n *                              resources\n */\nvar Analyzer = function Analyzer(attachAST,\n                                 loader) {\n  this.loader = loader;\n\n  /**\n   * A list of all elements the `Analyzer` has metadata for.\n   * @member {Array.<ElementDescriptor>}\n   */\n  this.elements = [];\n\n  /**\n   * A view into `elements`, keyed by tag name.\n   * @member {Object.<string,ElementDescriptor>}\n   */\n  this.elementsByTagName = {};\n\n  /**\n   * A list of API features added to `Polymer.Base` encountered by the\n   * analyzer.\n   * @member {Array<FeatureDescriptor>}\n   */\n  this.features = [];\n\n  /**\n   * The behaviors collected by the analysis pass.\n   *\n   * @member {Array<BehaviorDescriptor>}\n   */\n  this.behaviors = [];\n\n  /**\n   * The behaviors collected by the analysis pass by name.\n   *\n   * @member {Object<string,BehaviorDescriptor>}\n   */\n  this.behaviorsByName = {};\n\n  /**\n   * A map, keyed by absolute path, of Document metadata.\n   * @member {Object<string,AnalyzedDocument>}\n   */\n  this.html = {};\n\n  /**\n   * A map, keyed by path, of HTML document ASTs.\n   * @type {Object}\n   */\n  this.parsedDocuments = {};\n\n  /**\n   * A map, keyed by path, of JS script ASTs.\n   *\n   * If the path is an HTML file with multiple scripts, the entry will be an array of scripts.\n   *\n   * @type {Object<string,Array<ParsedJS>>}\n   */\n  this.parsedScripts = {};\n\n  \n\n  /**\n   * A map, keyed by path, of document content.\n   * @type {Object}\n   */\n  this._content = {};\n};\n\n/**\n * Options for `Analyzer.analzye`\n * @typedef {Object} LoadOptions\n * @memberof hydrolysis\n * @property {boolean} noAnnotations Whether `annotate()` should be skipped.\n * @property {boolean} clean Whether the generated descriptors should be cleaned\n *     of redundant data.\n * @property {function(string): boolean} filter A predicate function that\n *     indicates which files should be ignored by the loader. By default all\n *     files not located under the dirname of `href` will be ignored.\n */\n\n/**\n * Shorthand for transitively loading and processing all imports beginning at\n * `href`.\n *\n * In order to properly filter paths, `href` _must_ be an absolute URI.\n *\n * @param {string} href The root import to begin loading from.\n * @param {LoadOptions=} options Any additional options for the load.\n * @return {Promise<Analyzer>} A promise that will resolve once `href` and its\n *     dependencies have been loaded and analyzed.\n */\nAnalyzer.analyze = function analyze(href, options) {\n  options = options || {};\n  options.filter = options.filter || _defaultFilter(href);\n\n  var loader = new FileLoader();\n  var PrimaryResolver = typeof window === 'undefined' ?\n                        require('./loader/fs-resolver') :\n                        require('./loader/xhr-resolver');\n  loader.addResolver(new PrimaryResolver(options));\n  loader.addResolver(new NoopResolver({test: options.filter}));\n\n  var analyzer = new this(null, loader);\n  return analyzer.metadataTree(href).then(function(root) {\n    if (!options.noAnnotations) {\n      analyzer.annotate();\n    }\n    if (options.clean) {\n      analyzer.clean();\n    }\n    return Promise.resolve(analyzer);\n  });\n};\n\n/**\n * @private\n * @param {string} href\n * @return {function(string): boolean}\n */\nfunction _defaultFilter(href) {\n  // Everything up to the last `/` or `\\`.\n  var base = href.match(/^(.*?)[^\\/\\\\]*$/)[1];\n  return function(uri) {\n    return uri.indexOf(base) !== 0;\n  };\n}\n\nAnalyzer.prototype.load = function load(href) {\n  return this.loader.request(href).then(function(content) {\n    return new Promise(function(resolve, reject) {\n      setTimeout(function() {\n        this._content[href] = content;\n        resolve(this._parseHTML(content, href));\n      }.bind(this), 0);\n    }.bind(this)).catch(function(err){\n      console.error(\"Error processing document at \" + href);\n      throw err;\n    });\n  }.bind(this));\n};\n\n/**\n * Returns an `AnalyzedDocument` representing the provided document\n * @private\n * @param  {string} htmlImport Raw text of an HTML document\n * @param  {string} href       The document's URL.\n * @return {AnalyzedDocument}       An  `AnalyzedDocument`\n */\nAnalyzer.prototype._parseHTML = function _parseHTML(htmlImport,\n                                                  href) {\n  if (href in this.html) {\n    return this.html[href];\n  }\n  var depsLoaded = [];\n  var depHrefs = [];\n  var metadataLoaded = Promise.resolve(EMPTY_METADATA);\n  var parsed;\n  try {\n    parsed = importParse(htmlImport, href);\n  } catch (err) {\n    console.error('Error parsing!');\n    throw err;\n  }\n  var htmlLoaded = Promise.resolve(parsed);\n  if (parsed.script) {\n    metadataLoaded = this._processScripts(parsed.script, href);\n  }\n  var commentText = parsed.comment.map(function(comment){\n    return dom5.getTextContent(comment);\n  });\n  var pseudoElements = docs.parsePseudoElements(commentText);\n  pseudoElements.forEach(function(element){\n    element.contentHref = href;\n    this.elements.push(element);\n    this.elementsByTagName[element.is] = element;\n  }.bind(this));\n  metadataLoaded = metadataLoaded.then(function(metadata){\n    var metadataEntry = {\n      elements: pseudoElements,\n      features: [],\n      behaviors: []\n    };\n    return [metadata, metadataEntry].reduce(reduceMetadata);\n  });\n  depsLoaded.push(metadataLoaded);\n\n\n  if (this.loader) {\n    var baseUri = href;\n    if (parsed.base.length > 1) {\n      console.error(\"Only one base tag per document!\");\n      throw \"Multiple base tags in \" + href;\n    } else if (parsed.base.length == 1) {\n      var baseHref = dom5.getAttribute(parsed.base[0], \"href\");\n      if (baseHref) {\n        baseHref = baseHref + \"/\";\n        baseUri = url.resolve(baseUri, baseHref);\n      }\n    }\n    parsed.import.forEach(function(link) {\n      var linkurl = dom5.getAttribute(link, 'href');\n      if (linkurl) {\n        var resolvedUrl = url.resolve(baseUri, linkurl);\n        depHrefs.push(resolvedUrl);\n        depsLoaded.push(this._dependenciesLoadedFor(resolvedUrl, href));\n      }\n    }.bind(this));\n    parsed.style.forEach(function(styleElement) {\n      if (polymerExternalStyle(styleElement)) {\n        var styleHref = dom5.getAttribute(styleElement, 'href');\n        if (href) {\n          styleHref = url.resolve(baseUri, styleHref);\n          depsLoaded.push(this.loader.request(styleHref).then(function(content){\n            this._content[styleHref] = content;\n          }.bind(this)));\n        }\n      }\n    }.bind(this));\n  }\n  depsLoaded = Promise.all(depsLoaded)\n        .then(function() {return depHrefs;})\n        .catch(function(err) {throw err;});\n  this.parsedDocuments[href] = parsed.ast;\n  this.html[href] = {\n      href: href,\n      htmlLoaded: htmlLoaded,\n      metadataLoaded: metadataLoaded,\n      depHrefs: depHrefs,\n      depsLoaded: depsLoaded\n  };\n  return this.html[href];\n};\n\nAnalyzer.prototype._processScripts = function _processScripts(scripts, href) {\n  var scriptPromises = [];\n  scripts.forEach(function(script) {\n    scriptPromises.push(this._processScript(script, href));\n  }.bind(this));\n  return Promise.all(scriptPromises).then(function(metadataList) {\n    return metadataList.reduce(reduceMetadata, EMPTY_METADATA);\n  });\n};\n\nAnalyzer.prototype._processScript = function _processScript(script, href) {\n  var src = dom5.getAttribute(script, 'src');\n  var parsedJs;\n  if (!src) {\n    try {\n      parsedJs = jsParse((script.childNodes.length) ? script.childNodes[0].value : '');\n    } catch (err) {\n      // Figure out the correct line number for the error.\n      var line = 0;\n      var col = 0;\n      if (script.__ownerDocument && script.__ownerDocument == href) {\n        line = script.__locationDetail.line - 1;\n        col = script.__locationDetail.line - 1;\n      }\n      line += err.lineNumber;\n      col += err.column;\n      var message = \"Error parsing script in \" + href + \" at \" + line + \":\" + col;\n      message += \"\\n\" + err.description;\n      return Promise.reject(new Error(message));\n    }\n    if (parsedJs.elements) {\n      parsedJs.elements.forEach(function(element) {\n        element.scriptElement = script;\n        element.contentHref = href;\n        this.elements.push(element);\n        if (element.is in this.elementsByTagName) {\n          console.warn('Ignoring duplicate element definition: ' + element.is);\n        } else {\n          this.elementsByTagName[element.is] = element;\n        }\n      }.bind(this));\n    }\n    if (parsedJs.features) {\n      parsedJs.features.forEach(function(feature){\n        feature.contentHref = href;\n        feature.scriptElement = script;\n      });\n      this.features = this.features.concat(parsedJs.features);\n    }\n    if (parsedJs.behaviors) {\n      parsedJs.behaviors.forEach(function(behavior){\n        behavior.contentHref = href;\n        this.behaviorsByName[behavior.is] = behavior;\n        this.behaviorsByName[behavior.symbol] = behavior;\n      }.bind(this));\n      this.behaviors = this.behaviors.concat(parsedJs.behaviors);\n    }\n    if (!Object.hasOwnProperty.call(this.parsedScripts, href)) {\n      this.parsedScripts[href] = [];\n    }\n    var scriptElement;\n    if (script.__ownerDocument && script.__ownerDocument == href) {\n      scriptElement = script;\n    }\n    this.parsedScripts[href].push({\n      ast: parsedJs.parsedScript,\n      scriptElement: scriptElement\n    });\n    return parsedJs;\n  }\n  if (this.loader) {\n    var resolvedSrc = url.resolve(href, src);\n    return this.loader.request(resolvedSrc).then(function(content) {\n      this._content[resolvedSrc] = content;\n      var resolvedScript = Object.create(script);\n      resolvedScript.childNodes = [{value: content}];\n      resolvedScript.attrs = resolvedScript.attrs.slice();\n      dom5.removeAttribute(resolvedScript, 'src');\n      return this._processScript(resolvedScript, resolvedSrc);\n    }.bind(this)).catch(function(err) {throw err;});\n  } else {\n    return Promise.resolve(EMPTY_METADATA);\n  }\n};\n\nAnalyzer.prototype._dependenciesLoadedFor = function _dependenciesLoadedFor(href, root) {\n  var found = {};\n  if (root !== undefined) {\n    found[root] = true;\n  }\n  return this._getDependencies(href, found).then(function(deps) {\n    var depMetadataLoaded = [];\n    var depPromises = deps.map(function(depHref){\n      return this.load(depHref).then(function(htmlMonomer) {\n        return htmlMonomer.metadataLoaded;\n      });\n    }.bind(this));\n    return Promise.all(depPromises);\n  }.bind(this));\n};\n\n/**\n * List all the html dependencies for the document at `href`.\n * @param  {string}                   href      The href to get dependencies for.\n * @param  {Object.<string,boolean>=} found     An object keyed by URL of the\n *     already resolved dependencies.\n * @param  {boolean=}                transitive Whether to load transitive\n *     dependencies. Defaults to true.\n * @return {Array.<string>}  A list of all the html dependencies.\n */\nAnalyzer.prototype._getDependencies = function _getDependencies(href, found, transitive) {\n  if (found === undefined) {\n    found = {};\n    found[href] = true;\n  }\n  if (transitive === undefined) {\n    transitive = true;\n  }\n  var deps = [];\n  return this.load(href).then(function(htmlMonomer) {\n    var transitiveDeps = [];\n    htmlMonomer.depHrefs.forEach(function(depHref){\n      if (found[depHref]) {\n        return;\n      }\n      deps.push(depHref);\n      found[depHref] = true;\n      if (transitive) {\n        transitiveDeps.push(this._getDependencies(depHref, found));\n      }\n    }.bind(this));\n    return Promise.all(transitiveDeps);\n  }.bind(this)).then(function(transitiveDeps) {\n    var alldeps = transitiveDeps.reduce(function(a, b) {\n      return a.concat(b);\n    }, []).concat(deps);\n    return alldeps;\n  });\n};\n\nfunction matchesDocumentFolder(descriptor, href) {\n  if (!descriptor.contentHref) {\n    return false;\n  }\n  var descriptorDoc = url.parse(descriptor.contentHref);\n  if (!descriptorDoc || !descriptorDoc.pathname) {\n    return false;\n  }\n  var searchDoc = url.parse(href);\n  if (!searchDoc || !searchDoc.pathname) {\n    return false;\n  }\n  var searchPath = searchDoc.pathname;\n  var lastSlash = searchPath.lastIndexOf(\"/\");\n  if (lastSlash > 0) {\n    searchPath = searchPath.slice(0, lastSlash);\n  }\n  return descriptorDoc.pathname.indexOf(searchPath) === 0;\n}\n\nAnalyzer.prototype.elementsForFolder = function elementsForFolder(href) {\n  return this.elements.filter(function(element){\n    return matchesDocumentFolder(element, href);\n  });\n};\n\nAnalyzer.prototype.behaviorsForFolder = function behaviorsForFolder(href) {\n  return this.behaviors.filter(function(behavior){\n    return matchesDocumentFolder(behavior, href);\n  });\n};\n\n/**\n * Returns a promise that resolves to a POJO representation of the import\n * tree, in a format that maintains the ordering of the HTML imports spec.\n * @param {string} href the import to get metadata for.\n * @return {Promise}\n */\nAnalyzer.prototype.metadataTree = function metadataTree(href) {\n  return this.load(href).then(function(monomer){\n    var loadedHrefs = {};\n    loadedHrefs[href] = true;\n    return this._metadataTree(monomer, loadedHrefs);\n  }.bind(this));\n};\n\nAnalyzer.prototype._metadataTree = function _metadataTree(htmlMonomer,\n                                                          loadedHrefs) {\n  if (loadedHrefs === undefined) {\n    loadedHrefs = {};\n  }\n  return htmlMonomer.metadataLoaded.then(function(metadata) {\n    metadata = {\n      elements: metadata.elements,\n      features: metadata.features,\n      href: htmlMonomer.href\n    };\n    return htmlMonomer.depsLoaded.then(function(hrefs) {\n      var depMetadata = [];\n      hrefs.forEach(function(href) {\n        var metadataPromise = Promise.resolve(true);\n        if (depMetadata.length > 0) {\n          metadataPromise = depMetadata[depMetadata.length - 1];\n        }\n        metadataPromise = metadataPromise.then(function() {\n          if (!loadedHrefs[href]) {\n            loadedHrefs[href] = true;\n            return this._metadataTree(this.html[href], loadedHrefs);\n          } else {\n            return Promise.resolve({});\n          }\n        }.bind(this));\n        depMetadata.push(metadataPromise);\n      }.bind(this));\n      return Promise.all(depMetadata).then(function(importMetadata) {\n        metadata.imports = importMetadata;\n        return htmlMonomer.htmlLoaded.then(function(parsedHtml) {\n          metadata.html = parsedHtml;\n          if (metadata.elements) {\n            metadata.elements.forEach(function(element) {\n              attachDomModule(parsedHtml, element);\n            });\n          }\n          return metadata;\n        });\n      });\n    }.bind(this));\n  }.bind(this));\n};\n\nfunction matchingImport(importElement) {\n  var matchesTag = dom5.predicates.hasTagName(importElement.tagName);\n  var matchesHref = dom5.predicates.hasAttrValue('href', dom5.getAttribute(importElement, 'href'));\n  var matchesRel = dom5.predicates.hasAttrValue('rel', dom5.getAttribute(importElement, 'rel'));\n  return dom5.predicates.AND(matchesTag, matchesHref, matchesRel);\n}\n\n// TODO(ajo): Refactor out of vulcanize into dom5.\nvar polymerExternalStyle = dom5.predicates.AND(\n  dom5.predicates.hasTagName('link'),\n  dom5.predicates.hasAttrValue('rel', 'import'),\n  dom5.predicates.hasAttrValue('type', 'css')\n);\n\nvar externalScript = dom5.predicates.AND(\n  dom5.predicates.hasTagName('script'),\n  dom5.predicates.hasAttr('src')\n);\n\nvar isHtmlImportNode = dom5.predicates.AND(\n  dom5.predicates.hasTagName('link'),\n  dom5.predicates.hasAttrValue('rel', 'import'),\n  dom5.predicates.NOT(\n    dom5.predicates.hasAttrValue('type', 'css')\n  )\n);\n\nAnalyzer.prototype._inlineStyles = function _inlineStyles(ast, href) {\n  var cssLinks = dom5.queryAll(ast, polymerExternalStyle);\n  cssLinks.forEach(function(link) {\n    var linkHref = dom5.getAttribute(link, 'href');\n    var uri = url.resolve(href, linkHref);\n    var content = this._content[uri];\n    var style = dom5.constructors.element('style');\n    dom5.setTextContent(style, '\\n' + content + '\\n');\n    dom5.replace(link, style);\n  }.bind(this));\n  return cssLinks.length > 0;\n};\n\nAnalyzer.prototype._inlineScripts = function _inlineScripts(ast, href) {\n  var scripts = dom5.queryAll(ast, externalScript);\n  scripts.forEach(function(script) {\n    var scriptHref = dom5.getAttribute(script, 'src');\n    var uri = url.resolve(href, scriptHref);\n    var content = this._content[uri];\n    var inlined = dom5.constructors.element('script');\n    dom5.setTextContent(inlined, '\\n' + content + '\\n');\n    dom5.replace(script, inlined);\n  }.bind(this));\n  return scripts.length > 0;\n};\n\nAnalyzer.prototype._inlineImports = function _inlineImports(ast, href, loaded) {\n  var imports = dom5.queryAll(ast, isHtmlImportNode);\n  imports.forEach(function(htmlImport) {\n    var importHref = dom5.getAttribute(htmlImport, 'href');\n    var uri = url.resolve(href, importHref);\n    if (loaded[uri]) {\n      dom5.remove(htmlImport);\n      return;\n    }\n    var content = this.getLoadedAst(uri, loaded);\n    dom5.replace(htmlImport, content);\n  }.bind(this));\n  return imports.length > 0;\n};\n\n/**\n * Returns a promise resolving to a form of the AST with all links replaced\n * with the document they link to. .css and .script files become &lt;style&gt; and\n * &lt;script&gt;, respectively.\n *\n * The elements in the loaded document are unmodified from their original\n * documents.\n *\n * @param {string} href The document to load.\n * @param {Object.<string,boolean>=} loaded An object keyed by already loaded documents.\n * @return {Promise.<DocumentAST>}\n */\nAnalyzer.prototype.getLoadedAst = function getLoadedAst(href, loaded) {\n  if (!loaded) {\n    loaded = {};\n  }\n  loaded[href] = true;\n  var parsedDocument = this.parsedDocuments[href];\n  var analyzedDocument = this.html[href];\n  var astCopy = dom5.parse(dom5.serialize(parsedDocument));\n  // Whenever we inline something, reset inlined to true to know that anoather\n  // inlining pass is needed;\n  this._inlineStyles(astCopy, href);\n  this._inlineScripts(astCopy, href);\n  this._inlineImports(astCopy, href, loaded);\n  return astCopy;\n};\n\n/**\n * Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.\n * @param  {Object} predicate A dom5 predicate.\n * @return {Object}\n */\nAnalyzer.prototype.nodeWalkDocuments = function nodeWalkDocuments(predicate) {\n  for (var href in this.parsedDocuments) {\n    var match = dom5.nodeWalk(this.parsedDocuments[href], predicate);\n    if (match) {\n      return match;\n    }\n  }\n  return null;\n};\n\n/**\n * Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.\n * @param  {Object} predicate A dom5 predicate.\n * @return {Object}\n */\nAnalyzer.prototype.nodeWalkAllDocuments = function nodeWalkDocuments(predicate) {\n  var results = [];\n  for (var href in this.parsedDocuments) {\n    var newNodes = dom5.nodeWalkAll(this.parsedDocuments[href], predicate);\n    results = results.concat(newNodes);\n  }\n  return results;\n};\n\n/** Annotates all loaded metadata with its documentation. */\nAnalyzer.prototype.annotate = function annotate() {\n  if (this.features.length > 0) {\n    var featureEl = docs.featureElement(this.features);\n    this.elements.unshift(featureEl);\n    this.elementsByTagName[featureEl.is] = featureEl;\n  }\n  var behaviorsByName = this.behaviorsByName;\n  var elementHelper = function(descriptor){\n    docs.annotateElement(descriptor, behaviorsByName);\n  };\n  this.elements.forEach(elementHelper);\n  this.behaviors.forEach(elementHelper); // Same shape.\n  this.behaviors.forEach(function(behavior){\n    if (behavior.is !== behavior.symbol && behavior.symbol) {\n      this.behaviorsByName[behavior.symbol] = undefined;\n    }\n  }.bind(this));\n};\n\nfunction attachDomModule(parsedImport, element) {\n  var domModules = parsedImport['dom-module'];\n  for (var i = 0, domModule; i < domModules.length; i++) {\n    domModule = domModules[i];\n    if (dom5.getAttribute(domModule, 'id') === element.is) {\n      element.domModule = domModule;\n      return;\n    }\n  }\n}\n\n/** Removes redundant properties from the collected descriptors. */\nAnalyzer.prototype.clean = function clean() {\n  this.elements.forEach(docs.cleanElement);\n};\n\nmodule.exports = Analyzer;\n"]}
+},{"./ast-utils/docs":5,"./ast-utils/import-parse":10,"./ast-utils/js-parse":11,"./loader/file-loader":13,"./loader/fs-resolver":14,"./loader/noop-resolver":15,"./loader/xhr-resolver":16,"dom5":38,"es6-promise":60,"url":26}],2:[function(require,module,exports){
 /**
  * @license
  * Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
@@ -820,7 +922,7 @@ function arrayExpressionToValue(arry) {
   for (var i=0; i<arry.elements.length; i++) {
     var v = expressionToValue(arry.elements[i]);
     if (v === undefined)
-      v = CANT_CONVERT;
+      continue;
     if (i !== 0)
       value += ', ';
     value += v;
@@ -838,7 +940,7 @@ function objectExpressionToValue(obj) {
     var k = expressionToValue(obj.properties[i].key);
     var v = expressionToValue(obj.properties[i].value);
     if (v === undefined)
-      v = CANT_CONVERT;
+      continue;
     if (i !== 0)
       value += ', ';
     value += '"' + k + '": ' + v;
@@ -967,6 +1069,35 @@ module.exports = function behaviorFinder() {
     return newBehavior;
   }
  
+  /**
+   * gets the expression representing a behavior from a node.
+   */
+  function behaviorExpression(node) {
+    switch(node.type) {
+      case 'ExpressionStatement':
+        return node.expression.right;
+      case 'VariableDeclaration':
+        return node.declarations.length > 0 ? node.declarations[0].init : null;
+    }
+  }
+
+  /**
+   * checks whether an expression is a simple array containing only member
+   * expressions or identifiers.
+   */
+  function isSimpleBehaviorArray(expression) {
+    if (!expression || expression.type !== 'ArrayExpression') return false;
+    for (var i=0; i < expression.elements.length; i++) {
+      if (expression.elements[i].type !== 'MemberExpression' &&
+          expression.elements[i].type !== 'Identifier') {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  var templatizer = "Polymer.Templatizer";
+
   var visitors = {
  
     /**
@@ -993,20 +1124,14 @@ module.exports = function behaviorFinder() {
       // inside the array. Ex:
       // Polymer.IronMultiSelectableBehavior = [ {....}, Polymer.IronSelectableBehavior]
       // We add these to behaviors array
-      var expression;
-      switch(node.type) {
-        case 'ExpressionStatement':
-          expression = node.expression.right;
-        break;
-        case 'VariableDeclaration':
-          expression = node.declarations.length > 0 ? node.declarations[0].init : null;
-        break;
-      }
+      var expression = behaviorExpression(node);
       var chained = [];
       if (expression && expression.type === 'ArrayExpression') {
         for (var i=0; i < expression.elements.length; i++) {
-          if (expression.elements[i].type === 'MemberExpression')
+          if (expression.elements[i].type === 'MemberExpression' ||
+              expression.elements[i].type === 'Identifier') {
             chained.push(astValue.expressionToValue(expression.elements[i]));
+          }
         }
         if (chained.length > 0)
           currentBehavior.behaviors = chained;
@@ -1015,8 +1140,13 @@ module.exports = function behaviorFinder() {
  
     _initBehavior: function(node, getName) {
       var comment = esutil.getAttachedComment(node);
+      var symbol = getName();
       // Quickly filter down to potential candidates.
-      if (!comment || comment.indexOf('@polymerBehavior') === -1) return;
+      if (!comment || comment.indexOf('@polymerBehavior') === -1) {
+        if (symbol !== templatizer) {
+          return;
+        }
+      }
  
  
       currentBehavior = {
@@ -1029,14 +1159,16 @@ module.exports = function behaviorFinder() {
  
       docs.annotateBehavior(currentBehavior);
       // Make sure that we actually parsed a behavior tag!
-      if (!jsdoc.hasTag(currentBehavior.jsdoc, 'polymerBehavior')) {
+      if (!jsdoc.hasTag(currentBehavior.jsdoc, 'polymerBehavior') &&
+          symbol !== templatizer) {
         currentBehavior = null;
         return;
       }
  
       var name = jsdoc.getTag(currentBehavior.jsdoc, 'polymerBehavior', 'name');
+      currentBehavior.symbol = symbol;
       if (!name) {
-        name = getName();
+        name = currentBehavior.symbol;
       }
       if (!name) {
         console.warn('Unable to determine name for @polymerBehavior:', comment);
@@ -1046,6 +1178,16 @@ module.exports = function behaviorFinder() {
       this._parseChainedBehaviors(node);
  
       currentBehavior = mergeBehavior(currentBehavior);
+
+      // Some behaviors are just lists of other behaviors. If this is one then
+      // add it to behaviors right away.
+      if (isSimpleBehaviorArray(behaviorExpression(node))) {
+        // TODO(ajo): Add a test to confirm the presence of `properties`.
+        if (!currentBehavior.properties) currentBehavior.properties = [];
+        if (behaviors.indexOf(currentBehavior) === -1)
+          behaviors.push(currentBehavior);
+        currentBehavior = null;
+      }
     },
  
     /**
@@ -1180,6 +1322,54 @@ function annotateElementHeader(descriptor) {
   }
 }
  
+function matchByName(propa, propb) {
+  return propa.name == propb.name;
+}
+
+function copyProperties(from, to, behaviorsByName) {
+  if (from.properties) {
+    from.properties.forEach(function(fromProp){
+      for (var toProp, i = 0; i < to.properties.length; i++) {
+        toProp = to.properties[i];
+        if (fromProp.name === toProp.name) {
+          return;
+        }
+      }
+      var newProp = {__fromBehavior: from.is};
+      if (fromProp.__fromBehavior) {
+        return;
+      }
+      Object.keys(fromProp).forEach(function(propertyField){
+        newProp[propertyField] = fromProp[propertyField];
+      });
+      to.properties.push(newProp);
+    });
+  }
+  if (!from.behaviors) {
+    return;
+  }
+  from.behaviors.forEach(function(behavior){
+    var definedBehavior = behaviorsByName[behavior] || behaviorsByName[behavior.symbol];
+    if (!definedBehavior) {
+      return;
+    }
+    copyProperties(definedBehavior, to, behaviorsByName);
+  });
+}
+
+function mixinBehaviors(descriptor, behaviorsByName) {
+  if (descriptor.behaviors) {
+    descriptor.behaviors.forEach(function(behavior){
+      if (!behaviorsByName[behavior]) {
+        console.warn("Behavior " + behavior + " not found!");
+        return;
+      }
+      var definedBehavior = behaviorsByName[behavior];
+      copyProperties(definedBehavior, descriptor, behaviorsByName);
+    });
+  }
+}
+
 /**
  * Annotates documentation found within a Hydrolysis element descriptor. Also
  * supports behaviors.
@@ -1190,7 +1380,7 @@ function annotateElementHeader(descriptor) {
  * @param {Object} descriptor The element descriptor.
  * @return {Object} The descriptor that was given.
  */
-function annotateElement(descriptor) {
+function annotateElement(descriptor, behaviorsByName) {
   if (!descriptor.desc && descriptor.type === 'element') {
     descriptor.desc = _findElementDocs(descriptor.is,
                                        descriptor.domModule,
@@ -1201,8 +1391,11 @@ function annotateElement(descriptor) {
   // The `<dom-module>` is too low level for most needs, and it is _not_
   // serializable. So we drop it now that we've extracted all the useful bits
   // from it.
+  // TODO: Don't worry about serializability here, provide an API to get JSON.
   delete descriptor.domModule;
  
+  mixinBehaviors(descriptor, behaviorsByName);
+
   // Descriptors that should have their `desc` properties parsed as JSDoc.
   descriptor.properties.forEach(function(property) {
     // Feature properties are special, configuration is really just a matter of
@@ -1235,9 +1428,8 @@ function annotateElement(descriptor) {
  * @param {Object} descriptor behavior descriptor
  * @return {Object} descriptor passed in as param
  */
-function annotateBehavior(descriptor) {
+function annotateBehavior(descriptor, behaviorsByName) {
   annotate(descriptor);
-
   annotateElementHeader(descriptor);
  
   return descriptor;
@@ -1296,7 +1488,10 @@ function annotateProperty(descriptor, ignoreConfiguration) {
   // @default JSDoc wins
   var defaultTag = jsdoc.getTag(descriptor.jsdoc, 'default');
   if (defaultTag !== null) {
-    descriptor.default = (defaultTag.name || '') + (defaultTag.description || '');
+    var newDefault = (defaultTag.name || '') + (defaultTag.description || '');
+    if (newDefault !== '') {
+      descriptor.default = newDefault;
+    }
   }
  
   return descriptor;
@@ -1408,6 +1603,30 @@ function cleanProperty(property) {
 }
  
 /**
+ * Parse elements defined only in comments.
+ * @param  {comments} Array<string> A list of comments to parse.
+ * @return {ElementDescriptor}      A list of pseudo-elements.
+ */
+function parsePseudoElements(comments) {
+  var elements = [];
+  comments.forEach(function(comment) {
+    var parsed = jsdoc.parseJsdoc(comment);
+    var pseudoTag = jsdoc.getTag(parsed, 'pseudoElement', 'name');
+    if (pseudoTag) {
+      parsed.is = pseudoTag;
+      parsed.jsdoc = {description: parsed.description, tags: parsed.tags};
+      parsed.properties = [];
+      parsed.desc = parsed.description;
+      parsed.description = undefined;
+      parsed.tags = undefined;
+      annotateElementHeader(parsed);
+      elements.push(parsed);
+    }
+  });
+  return elements;
+}
+
+/**
  * @param {string} elementId
  * @param {DocumentAST} domModule
  * @param {DocumentAST} scriptElement The script that the element was defined in.
@@ -1470,6 +1689,7 @@ module.exports = {
   clean:           clean,
   cleanElement:    cleanElement,
   featureElement:  featureElement,
+  parsePseudoElements: parsePseudoElements
 };
  
 },{"./jsdoc":12,"dom5":38}],6:[function(require,module,exports){
@@ -1525,7 +1745,6 @@ var elementFinder = function elementFinder() {
       if (node.type != 'ArrayExpression') {
         return;
       }
-      element.behaviors = [];
  
       for (var i=0; i<node.elements.length; i++) {
         var v = astValue.expressionToValue(node.elements[i]);
@@ -1566,6 +1785,7 @@ var elementFinder = function elementFinder() {
     enterObjectExpression: function enterObjectExpression(node, parent) {
       if (element && !element.properties) {
         element.properties = [];
+        element.behaviors = [];
         for (var i = 0; i < node.properties.length; i++) {
           var prop = node.properties[i];
           var name = esutil.objectKeyToString(prop.key);
@@ -1883,13 +2103,30 @@ var isStyleNode = p.OR(
   )
 );
  
+var isJSScriptNode = p.AND(
+  p.hasTagName('script'),
+  p.OR(
+    p.NOT(p.hasAttr('type')),
+    p.hasAttrValue('type', 'text/javascript'),
+    p.hasAttrValue('type', 'application/javascript')
+  )
+);
+
 function addNode(node, registry) {
   if (isHtmlImportNode(node)) {
     registry.import.push(node);
   } else if (isStyleNode(node)) {
     registry.style.push(node);
-  } else if (registry.hasOwnProperty(node.tagName)) {
-    registry[node.tagName].push(node);
+  } else if (isJSScriptNode(node)) {
+    registry.script.push(node);
+  } else if (node.tagName === 'base') {
+    registry.base.push(node);
+  } else if (node.tagName === 'template') {
+    registry.template.push(node);
+  } else if (node.tagName === 'dom-module') {
+    registry['dom-module'].push(node);
+  } else if (dom5.isCommentNode(node)) {
+    registry.comment.push(node);
   }
 }
  
@@ -1951,13 +2188,14 @@ var importParse = function importParse(htmlString, href) {
       script: [],
       style: [],
       import: [],
-      'dom-module': []};
+      'dom-module': [],
+      comment: []};
  
   var queue = [].concat(doc.childNodes);
   var nextNode;
   while (queue.length > 0) {
     nextNode = queue.shift();
-    if (nextNode && nextNode.tagName) {
+    if (nextNode) {
       queue = queue.concat(nextNode.childNodes);
       addNode(nextNode, registry);
     }
@@ -2058,6 +2296,7 @@ var jsParse = function jsParse(jsString) {
     behaviors: behaviorInfo.behaviors,
     elements:  elementInfo.elements,
     features:  featureInfo.features,
+    parsedScript: script
   };
 };
  
@@ -2376,7 +2615,7 @@ FileLoader.prototype = {
       }
  
       if (!handled) {
-        deferred.reject('no resolver found');
+        deferred.reject(new Error('no resolver found for ' + uri));
       }
  
       promise = deferred.promise;
@@ -2391,7 +2630,7 @@ FileLoader.prototype = {
 module.exports = FileLoader;
  
 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,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
 },{"es6-promise":60}],14:[function(require,module,exports){
 /**
  * @license
@@ -3221,7 +3460,7 @@ var substr = &#39;ab&#39;.substr(-1) === &#39;b&#39;
 ;
  
 }).call(this,require('_process'))
-
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/path-browserify/index.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar splitPath = function(filename) {\n  return splitPathRe.exec(filename).slice(1);\n};\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nexports.basename = function(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nexports.extname = function(path) {\n  return splitPath(path)[3];\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n"]}
 },{"_process":21}],21:[function(require,module,exports){
 // shim for using process in browser
  
@@ -3793,7 +4032,7 @@ process.umask = function() { return 0; };
 }(this));
  
 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/punycode/punycode.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["/*! http://mths.be/punycode v1.2.4 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /\\x2E|\\u3002|\\uFF0E|\\uFF61/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\twhile (length--) {\n\t\t\tarray[length] = fn(array[length]);\n\t\t}\n\t\treturn array;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings.\n\t * @private\n\t * @param {String} domain The domain name.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\treturn map(string.split(regexSeparators), fn).join('.');\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <http://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * http://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols to a Punycode string of ASCII-only\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name to Unicode. Only the\n\t * Punycoded parts of the domain name will be converted, i.e. it doesn't\n\t * matter if you call it on a string that has already been converted to\n\t * Unicode.\n\t * @memberOf punycode\n\t * @param {String} domain The Punycode domain name to convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(domain) {\n\t\treturn mapDomain(domain, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name to Punycode. Only the\n\t * non-ASCII parts of the domain name will be converted, i.e. it doesn't\n\t * matter if you call it with a domain that's already in ASCII.\n\t * @memberOf punycode\n\t * @param {String} domain The domain name to convert, as a Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name.\n\t */\n\tfunction toASCII(domain) {\n\t\treturn mapDomain(domain, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.2.4',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <http://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n"]}
 },{}],23:[function(require,module,exports){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -5279,7 +5518,7 @@ function hasOwnProperty(obj, prop) {
 }
  
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/util/util.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n"]}
 },{"./support/isBuffer":27,"_process":21,"inherits":19}],29:[function(require,module,exports){
 /*
   Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
@@ -5607,6 +5846,10 @@ function hasOwnProperty(obj, prop) {
                     name += scanIdentifier(last);
  
                 }
+                if(source.charCodeAt(index) === 0x5B  /* '[' */ && source.charCodeAt(index + 1) === 0x5D  /* ']' */){
+                    name += advance();
+                    name += advance();
+                }
                 while (source.charCodeAt(index) === 0x2E  /* '.' */ ||
                         source.charCodeAt(index) === 0x23  /* '#' */ ||
                         source.charCodeAt(index) === 0x7E  /* '~' */) {
@@ -5864,7 +6107,9 @@ function hasOwnProperty(obj, prop) {
             // un-fix potentially sloppy declaration
             if (isParamTitle(this._title) && !this._tag.type && description && description.charAt(0) === '[') {
                 this._tag.type = this._extra.name;
-                this._tag.name = undefined;
+                if (!this._tag.name) {
+                    this._tag.name = undefined;
+                }
  
                 if (!sloppy) {
                     if (!this.addError('Missing or invalid tag name')) {
@@ -7847,7 +8092,7 @@ module.exports={
   "description": "JSDoc parser",
   "homepage": "http://github.com/Constellation/doctrine.html",
   "main": "lib/doctrine.js",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "engines": {
     "node": ">=0.10.0"
   },
@@ -7863,14 +8108,17 @@ module.exports={
   ],
   "maintainers": [
     {
-      "name": "Yusuke Suzuki",
-      "email": "utatane.tea@gmail.com",
-      "url": "http://github.com/Constellation"
+      "name": "constellation",
+      "email": "utatane.tea@gmail.com"
+    },
+    {
+      "name": "nzakas",
+      "email": "nicholas@nczconsulting.com"
     }
   ],
   "repository": {
     "type": "git",
-    "url": "http://github.com/Constellation/doctrine.git"
+    "url": "http://github.com/eslint/doctrine.git"
   },
   "devDependencies": {
     "coveralls": "^2.11.2",
@@ -7889,7 +8137,7 @@ module.exports={
   "licenses": [
     {
       "type": "BSD",
-      "url": "http://github.com/Constellation/doctrine/raw/master/LICENSE.BSD"
+      "url": "http://github.com/eslint/doctrine/raw/master/LICENSE.BSD"
     }
   ],
   "scripts": {
@@ -7902,17 +8150,23 @@ module.exports={
     "esutils": "^1.1.6",
     "isarray": "0.0.1"
   },
-  "gitHead": "4f74c86ea5cd03fbd947c4df91a2192d13779fb5",
-  "readme": "doctrine ([doctrine](http://github.com/Constellation/doctrine)) is JSDoc parser.\n\n[![Build Status](https://travis-ci.org/Constellation/doctrine.svg?branch=master)](https://travis-ci.org/Constellation/doctrine)\n[![Coverage Status](https://img.shields.io/coveralls/Constellation/doctrine.svg)](https://coveralls.io/r/Constellation/doctrine?branch=master)\n[![Dependency Status](https://david-dm.org/Constellation/doctrine.svg)](https://david-dm.org/Constellation/doctrine)\n[![devDependency Status](https://david-dm.org/Constellation/doctrine/dev-status.svg)](https://david-dm.org/Constellation/doctrine#info=devDependencies)\n[![Gitter chat](https://badges.gitter.im/Constellation/doctrine.png)](https://gitter.im/Constellation/doctrine)\n\nIt is now used by content assist system of [Eclipse Orion](http://www.eclipse.org/orion/) ([detail](http://planetorion.org/news/2012/10/orion-1-0-release/)). And used as JSDoc validator in [ESLint](http://eslint.org/).\n\nDoctrine can be used in a web browser with using browserify.\nor in a Node.js application via the package manager:\n\n    npm install doctrine\n\nsimple example:\n\n    doctrine.parse(\n        [\n            \"/**\",\n            \" * This function comment is parsed by doctrine\",\n            \" * @param {{ok:String}} userName\",\n            \"*/\"\n        ].join('\\n'), { unwrap: true });\n\nand gets following information\n\n    {\n        \"description\": \"This function comment is parsed by doctrine\",\n        \"tags\": [\n            {\n                \"title\": \"param\",\n                \"description\": null,\n                \"type\": {\n                    \"type\": \"RecordType\",\n                    \"fields\": [\n                        {\n                            \"type\": \"FieldType\",\n                            \"key\": \"ok\",\n                            \"value\": {\n                                \"type\": \"NameExpression\",\n                                \"name\": \"String\"\n                            }\n                        }\n                    ]\n                },\n                \"name\": \"userName\"\n            }\n        ]\n    }\n\nsee [demo page](http://constellation.github.com/doctrine/demo/index.html) more detail.\n\n### Options\n\n#### doctrine.parse\nWe can pass options to `doctrine.parse(comment, options)`.\n```js\n{\n    unwrap: boolean,          // default: false\n    tags: [ string ] | null,  // default: null\n    recoverable: boolean,     // default: false\n    sloppy: boolean,          // default: false\n    lineNumbers: boolean      // default: false\n}\n```\n\n##### unwrap\n\nWhen `unwrap` is `true`, doctrine attempt to unwrap comment specific string from a provided comment text. (removes `/**`, `*/` and `*`)\nFor example, `unwrap` transforms\n```\n/**\n * @param use\n */\n```\nto\n```\n@param use\n```\nIf a provided comment has these comment specific strings, you need to specify this `unwrap` option to `true`.\n\n##### tags\n\nWhen `tags` array is specified, doctrine only produce tags that is specified in this array.\nFor example, if you specify `[ 'param' ]`, doctrine only produces `param` tags.\nIf null is specified, doctrine produces all tags that doctrine can recognize.\n\n##### recoverable\n\nWhen `recoverable` is `true`, doctrine becomes `recoverable` - When failing to parse jsdoc comment, doctrine recovers its state and attempt to continue parsing.\n\n##### sloppy\n\nWhen `sloppy` is `true`,\n```\n@param String [foo]\n```\n's `[foo]` is interpreted as a optional parameter, not interpreted as a name of this `@param`.\n\n##### lineNumbers\n\nWhen `lineNumbers` is `true`, parsed tags will include a `lineNumber` property indicating the line (relative to the start of the comment block) where each tag is located in the source. So, given the following comment:\n```\n/**\n * @param {String} foo\n * @return {number}\n */\n```\nThe `@param` tag will have `lineNumber: 1`, and the `@return` tag will have `lineNumber: 2`.\n\n\n### License\n\n#### doctrine\n\nCopyright (C) 2012 [Yusuke Suzuki](http://github.com/Constellation)\n (twitter: [@Constellation](http://twitter.com/Constellation)) and other contributors.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n  * Redistributions of source code must retain the above copyright\n    notice, this list of conditions and the following disclaimer.\n\n  * Redistributions in binary form must reproduce the above copyright\n    notice, this list of conditions and the following disclaimer in the\n    documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\nTHIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n#### esprima\n\nsome of functions is derived from esprima\n\nCopyright (C) 2012, 2011 [Ariya Hidayat](http://ariya.ofilabs.com/about)\n (twitter: [@ariyahidayat](http://twitter.com/ariyahidayat)) and other contributors.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n  * Redistributions of source code must retain the above copyright\n    notice, this list of conditions and the following disclaimer.\n\n  * Redistributions in binary form must reproduce the above copyright\n    notice, this list of conditions and the following disclaimer in the\n    documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\nTHIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\n#### closure-compiler\n\nsome of extensions is derived from closure-compiler\n\nApache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n",
-  "readmeFilename": "README.md",
+  "gitHead": "0d059e422bdfd630eaa15d583567c8668923f7e6",
   "bugs": {
-    "url": "https://github.com/Constellation/doctrine/issues"
+    "url": "https://github.com/eslint/doctrine/issues"
+  },
+  "_id": "doctrine@0.7.0",
+  "_shasum": "dcc9589850b043d6e58abe24b561ccd57176cfd3",
+  "_from": "doctrine@*",
+  "_npmVersion": "1.4.28",
+  "_npmUser": {
+    "name": "nzakas",
+    "email": "nicholas@nczconsulting.com"
+  },
+  "dist": {
+    "shasum": "dcc9589850b043d6e58abe24b561ccd57176cfd3",
+    "tarball": "http://registry.npmjs.org/doctrine/-/doctrine-0.7.0.tgz"
   },
-  "_id": "doctrine@0.6.4",
-  "_shasum": "5b8d534412b49b8177b52082cd95df380de390aa",
-  "_from": "git://github.com/PolymerLabs/doctrine.git#master",
-  "_resolved": "git://github.com/PolymerLabs/doctrine.git#4f74c86ea5cd03fbd947c4df91a2192d13779fb5",
-  "_fromGithub": true
+  "_resolved": "https://registry.npmjs.org/doctrine/-/doctrine-0.7.0.tgz"
 }
  
 },{}],38:[function(require,module,exports){
@@ -8273,6 +8527,34 @@ function _reverseNodeWalkAll(node, predicate, matches) {
 }
  
 /**
+ * Equivalent to `nodeWalk`, but only returns nodes that are either
+ * ancestors or earlier cousins/siblings in the document.
+ *
+ * Nodes are searched in reverse document order, starting from the sibling
+ * prior to `node`.
+ */
+function nodeWalkPrior(node, predicate) {
+  // Search our earlier siblings and their descendents.
+  var parent = node.parentNode;
+  if (parent) {
+    var idx = parent.childNodes.indexOf(node);
+    var siblings = parent.childNodes.slice(0, idx);
+    for (var i = siblings.length-1; i >= 0; i--) {
+      var sibling = siblings[i];
+      if (predicate(sibling)) {
+        return sibling;
+      }
+      var found = nodeWalkPrior(sibling, predicate);
+    }
+    if (predicate(parent)) {
+      return parent;
+    }
+    return nodeWalkPrior(parent, predicate);
+  }
+  return undefined;
+}
+
+/**
  * Equivalent to `nodeWalkAll`, but only returns nodes that are either 
  * ancestors or earlier cousins/siblings in the document.
  *
@@ -8409,6 +8691,7 @@ module.exports = {
   queryAll: queryAll,
   nodeWalk: nodeWalk,