Commit e619a3b04c27b680d9afedcb1bf79eb1e9cbb441

Authored by Luigi Serra
1 parent 4963f51a

Controllet cross browser big fix

Showing 534 changed files with 10973 additions and 6512 deletions

Too many changes.

To preserve performance only 100 of 534 files are displayed.

bower_components/google-map/.bower.json 100755 → 100644
1 1 {
2 2 "name": "google-map",
3   - "version": "1.1.0",
  3 + "version": "1.1.2",
4 4 "description": "Google Maps web components",
5 5 "homepage": "https://googlewebcomponents.github.io/google-map",
6 6 "main": [
... ... @@ -36,11 +36,11 @@
36 36 "web-component-tester": "*",
37 37 "iron-component-page": "PolymerElements/iron-component-page#^1.0.2"
38 38 },
39   - "_release": "1.1.0",
  39 + "_release": "1.1.2",
40 40 "_resolution": {
41 41 "type": "version",
42   - "tag": "1.1.0",
43   - "commit": "c45ddfa8c48a67dda1b2237589edcd45bc3f7802"
  42 + "tag": "1.1.2",
  43 + "commit": "3567129ffac7df683346b5c9d8ad0c32e9213adb"
44 44 },
45 45 "_source": "git://github.com/GoogleWebComponents/google-map.git",
46 46 "_target": "^1.0.0",
... ...
bower_components/google-map/LICENSE 100755 → 100644
bower_components/google-map/README.md 100755 → 100644
bower_components/google-map/bower.json 100755 → 100644
1 1 {
2 2 "name": "google-map",
3   - "version": "1.1.0",
  3 + "version": "1.1.2",
4 4 "description": "Google Maps web components",
5 5 "homepage": "https://googlewebcomponents.github.io/google-map",
6 6 "main": [
... ...
bower_components/google-map/demo/index.html 100755 → 100644
bower_components/google-map/google-map-directions.html 100755 → 100644
bower_components/google-map/google-map-marker.html 100755 → 100644
... ... @@ -42,8 +42,23 @@ child of `google-map`.
42 42 </dom-module>
43 43  
44 44 <script>
45   -
46 45 (function() {
  46 +
  47 + function setupDragHandler_() {
  48 + if (this.draggable) {
  49 + this.dragHandler_ = google.maps.event.addListener(
  50 + this.marker, 'dragend', onDragEnd_.bind(this));
  51 + } else {
  52 + google.maps.event.removeListener(this.dragHandler_);
  53 + this.dragHandler_ = null;
  54 + }
  55 + }
  56 +
  57 + function onDragEnd_(e, details, sender) {
  58 + this.latitude = e.latLng.lat();
  59 + this.longitude = e.latLng.lng();
  60 + }
  61 +
47 62 Polymer({
48 63  
49 64 is: 'google-map-marker',
... ... @@ -53,45 +68,53 @@ child of `google-map`.
53 68 * @param {google.maps.MouseEvent} event The mouse event.
54 69 * @event google-map-marker-click
55 70 */
  71 +
56 72 /**
57 73 * Fired when the marker icon was double clicked. Requires the clickEvents attribute to be true.
58 74 * @param {google.maps.MouseEvent} event The mouse event.
59 75 * @event google-map-marker-dblclick
60 76 */
  77 +
61 78 /**
62 79 * Fired for a mousedown on the marker. Requires the mouseEvents attribute to be true.
63 80 * @event google-map-marker-mousedown
64 81 * @param {google.maps.MouseEvent} event The mouse event.
65 82 */
  83 +
66 84 /**
67 85 * Fired when the DOM `mousemove` event is fired on the marker. Requires the mouseEvents
68 86 * attribute to be true.
69 87 * @event google-map-marker-mousemove
70 88 * @param {google.maps.MouseEvent} event The mouse event.
71 89 */
  90 +
72 91 /**
73 92 * Fired when the mouse leaves the area of the marker icon. Requires the mouseEvents attribute to be
74 93 * true.
75 94 * @event google-map-marker-mouseout
76 95 * @param {google.maps.MouseEvent} event The mouse event.
77 96 */
  97 +
78 98 /**
79 99 * Fired when the mouse enters the area of the marker icon. Requires the mouseEvents attribute to be
80 100 * true.
81 101 * @event google-map-marker-mouseover
82 102 * @param {google.maps.MouseEvent} event The mouse event.
83 103 */
  104 +
84 105 /**
85 106 * Fired for a mouseup on the marker. Requires the mouseEvents attribute to be true.
86 107 *
87 108 * @event google-map-marker-mouseup
88 109 * @param {google.maps.MouseEvent} event The mouse event.
89 110 */
  111 +
90 112 /**
91 113 * Fired for a rightclick on the marker. Requires the clickEvents attribute to be true.
92 114 * @event google-map-marker-rightclick
93 115 * @param {google.maps.MouseEvent} event The mouse event.
94 116 */
  117 +
95 118 properties: {
96 119 /**
97 120 * A Google Maps marker object.
... ... @@ -161,6 +184,7 @@ child of `google-map`.
161 184 value: null,
162 185 reflectToAttribute: true
163 186 },
  187 +
164 188 /**
165 189 * The marker's latitude coordinate.
166 190 */
... ... @@ -168,6 +192,16 @@ child of `google-map`.
168 192 type: Number,
169 193 value: null,
170 194 reflectToAttribute: true
  195 + },
  196 +
  197 + /**
  198 + * A animation for the marker. "DROP" or "BOUNCE". See
  199 + * https://developers.google.com/maps/documentation/javascript/examples/marker-animations.
  200 + */
  201 + animation: {
  202 + type: String,
  203 + value: null,
  204 + observer: '_animationChanged'
171 205 }
172 206 },
173 207  
... ... @@ -231,6 +265,12 @@ child of `google-map`.
231 265 }
232 266 },
233 267  
  268 + _animationChanged: function() {
  269 + if (this.marker) {
  270 + this.marker.setAnimation(google.maps.Animation[this.animation]);
  271 + }
  272 + },
  273 +
234 274 _iconChanged: function() {
235 275 if (this.marker) {
236 276 this.marker.setIcon(this.icon);
... ... @@ -288,8 +328,12 @@ child of `google-map`.
288 328 this._listeners = {};
289 329 this.marker = new google.maps.Marker({
290 330 map: this.map,
291   - position: {lat: this.latitude, lng: this.longitude},
  331 + position: {
  332 + lat: parseFloat(this.latitude),
  333 + lng: parseFloat(this.longitude)
  334 + },
292 335 title: this.title,
  336 + animation: google.maps.Animation[this.animation],
293 337 draggable: this.draggable,
294 338 visible: !this.hidden,
295 339 icon: this.icon,
... ... @@ -336,19 +380,5 @@ child of `google-map`.
336 380 }
337 381 });
338 382  
339   - function setupDragHandler_() {
340   - if (this.draggable) {
341   - this.dragHandler_ = google.maps.event.addListener(
342   - this.marker, 'dragend', onDragEnd_.bind(this));
343   - } else {
344   - google.maps.event.removeListener(this.dragHandler_);
345   - this.dragHandler_ = null;
346   - }
347   - }
348   -
349   - function onDragEnd_(e, details, sender) {
350   - this.latitude = e.latLng.lat();
351   - this.longitude = e.latLng.lng();
352   - }
353 383 })();
354 384 </script>
... ...
bower_components/google-map/google-map-search.html 100755 → 100644
... ... @@ -11,7 +11,7 @@ information on the API.
11 11 #### Example:
12 12  
13 13 <template is="dom-bind">
14   - <google-map-search map="[[map]]" query="Pizza"
  14 + <google-map-search map="[[map]]" libraries="places" query="Pizza"
15 15 results="{{results}}"></google-map-search>
16 16 <google-map map="{{map}}" latitude="37.779"
17 17 longitude="-122.3892">
... ... @@ -119,7 +119,7 @@ information on the API.
119 119 location: {
120 120 type: Object,
121 121 value: null,
122   - readyOnly: true
  122 + readOnly: true
123 123 }
124 124 },
125 125  
... ... @@ -129,6 +129,13 @@ information on the API.
129 129 ],
130 130  
131 131 /**
  132 + * Fired when the details of a place are returned.
  133 + *
  134 + * @event google-map-search-place-detail
  135 + * @param {google.maps.MarkerPlace} detail The place details.
  136 + */
  137 +
  138 + /**
132 139 * Fired when the search element returns a result.
133 140 *
134 141 * @event google-map-search-results
... ... @@ -166,6 +173,26 @@ information on the API.
166 173 }
167 174 },
168 175  
  176 + /**
  177 + * Fetches details for a given place.
  178 + * @param {String} placeId The place id.
  179 + * @return {Promise} place The place information.
  180 + */
  181 + getDetails: function(placeId) {
  182 + var places = new google.maps.places.PlacesService(this.map);
  183 +
  184 + return new Promise(function(resolve, reject) {
  185 + places.getDetails({placeId: placeId}, function(place, status) {
  186 + if (status === google.maps.places.PlacesServiceStatus.OK) {
  187 + resolve(place);
  188 + this.fire('google-map-search-place-detail', place);
  189 + } else {
  190 + reject(status);
  191 + }
  192 + }.bind(this));
  193 + }.bind(this));
  194 + },
  195 +
169 196 _gotResults: function(results, status) {
170 197 this.results = results.map(function(result) {
171 198 // obtain lat/long from geometry
... ...
bower_components/google-map/google-map.html 100755 → 100644
... ... @@ -204,7 +204,8 @@ The `google-map` element renders a Google Map.
204 204 zoom: {
205 205 type: Number,
206 206 value: 10,
207   - observer: '_zoomChanged'
  207 + observer: '_zoomChanged',
  208 + notify: true
208 209 },
209 210  
210 211 /**
... ... @@ -221,7 +222,8 @@ The `google-map` element renders a Google Map.
221 222 mapType: {
222 223 type: String,
223 224 value: 'roadmap', // roadmap, satellite, hybrid, terrain,
224   - observer: '_mapTypeChanged'
  225 + observer: '_mapTypeChanged',
  226 + notify: true
225 227 },
226 228  
227 229 /**
... ... @@ -671,6 +673,10 @@ The `google-map` element renders a Google Map.
671 673 google.maps.event.addListener(this.map, 'zoom_changed', function() {
672 674 this.zoom = this.map.getZoom();
673 675 }.bind(this));
  676 +
  677 + google.maps.event.addListener(this.map, 'maptypeid_changed', function() {
  678 + this.mapType = this.map.getMapTypeId();
  679 + }.bind(this));
674 680  
675 681 this._clickEventsChanged();
676 682 this._dragEventsChanged();
... ...
bower_components/google-map/index.html 100755 → 100644
bower_components/google-map/metadata.html 100755 → 100644
bower_components/hydrolysis/.bower.json 100755 → 100644
... ... @@ -19,13 +19,13 @@
19 19 "webcomponentsjs": "webcomponents/webcomponentsjs#^0.7.0",
20 20 "web-component-tester": "*"
21 21 },
22   - "version": "1.15.2",
  22 + "version": "1.19.0",
23 23 "homepage": "https://github.com/Polymer/hydrolysis",
24   - "_release": "1.15.2",
  24 + "_release": "1.19.0",
25 25 "_resolution": {
26 26 "type": "version",
27   - "tag": "v1.15.2",
28   - "commit": "3b255182fd39a273c255ac2a49db8d06d96f667d"
  27 + "tag": "v1.19.0",
  28 + "commit": "8b0e8410712cc465a35b854ce86bfb6b23e2e9ab"
29 29 },
30 30 "_source": "git://github.com/Polymer/hydrolysis.git",
31 31 "_target": "^1.11",
... ...
bower_components/hydrolysis/.editorconfig 100755 → 100644
bower_components/hydrolysis/.gitattributes 100755 → 100644
bower_components/hydrolysis/API.md 100755 → 100644
... ... @@ -24,31 +24,38 @@ Static analysis for Polymer.
24 24 * [.Analyzer](#hydrolysis.Analyzer)
25 25 * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
26 26 * _instance_
27   - * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
28   - * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
29   - * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
30   - * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
31   - * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
32   - * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
33   - * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
34   - * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
35   - * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
36   - * [.annotate()](#hydrolysis.Analyzer#annotate)
37   - * [.clean()](#hydrolysis.Analyzer#clean)
  27 + * [.elements](#hydrolysis.Analyzer+elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
  28 + * [.elementsByTagName](#hydrolysis.Analyzer+elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
  29 + * [.features](#hydrolysis.Analyzer+features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
  30 + * [.behaviors](#hydrolysis.Analyzer+behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
  31 + * [.behaviorsByName](#hydrolysis.Analyzer+behaviorsByName) : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
  32 + * [.html](#hydrolysis.Analyzer+html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
  33 + * [.parsedDocuments](#hydrolysis.Analyzer+parsedDocuments) : <code>Object</code>
  34 + * [.parsedScripts](#hydrolysis.Analyzer+parsedScripts) : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
  35 + * [._content](#hydrolysis.Analyzer+_content) : <code>Object</code>
  36 + * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer+_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
  37 + * [.metadataTree(href)](#hydrolysis.Analyzer+metadataTree) ⇒ <code>Promise</code>
  38 + * [.getLoadedAst(href, [loaded])](#hydrolysis.Analyzer+getLoadedAst) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
  39 + * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkDocuments) ⇒ <code>Object</code>
  40 + * [.nodeWalkAllDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkAllDocuments) ⇒ <code>Object</code>
  41 + * [.annotate()](#hydrolysis.Analyzer+annotate)
  42 + * [.clean()](#hydrolysis.Analyzer+clean)
38 43 * _static_
39 44 * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
40 45 * [.FileLoader](#hydrolysis.FileLoader)
41 46 * [new FileLoader()](#new_hydrolysis.FileLoader_new)
42   - * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
43   - * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
  47 + * [.addResolver(resolver)](#hydrolysis.FileLoader+addResolver)
  48 + * [.request(url)](#hydrolysis.FileLoader+request) ⇒ <code>Promise.&lt;string&gt;</code>
44 49 * [.FSResolver](#hydrolysis.FSResolver)
45 50 * [new FSResolver(config)](#new_hydrolysis.FSResolver_new)
46 51 * [.NoopResolver](#hydrolysis.NoopResolver)
47 52 * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
48   - * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
  53 + * [.accept(uri, deferred)](#hydrolysis.NoopResolver+accept) ⇒ <code>boolean</code>
49 54 * [.XHRResolver](#hydrolysis.XHRResolver)
50 55 * [new XHRResolver(config)](#new_hydrolysis.XHRResolver_new)
51 56 * [.DocumentAST](#hydrolysis.DocumentAST) : <code>Object</code>
  57 + * [.JSAST](#hydrolysis.JSAST) : <code>Object</code>
  58 + * [.ParsedJS](#hydrolysis.ParsedJS) : <code>Object</code>
52 59 * [.ElementDescriptor](#hydrolysis.ElementDescriptor) : <code>Object</code>
53 60 * [.FeatureDescriptor](#hydrolysis.FeatureDescriptor) : <code>Object</code>
54 61 * [.BehaviorDescriptor](#hydrolysis.BehaviorDescriptor) : <code>Object</code>
... ... @@ -64,17 +71,22 @@ Static analysis for Polymer.
64 71 * [.Analyzer](#hydrolysis.Analyzer)
65 72 * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
66 73 * _instance_
67   - * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
68   - * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
69   - * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
70   - * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
71   - * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
72   - * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
73   - * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
74   - * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
75   - * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
76   - * [.annotate()](#hydrolysis.Analyzer#annotate)
77   - * [.clean()](#hydrolysis.Analyzer#clean)
  74 + * [.elements](#hydrolysis.Analyzer+elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
  75 + * [.elementsByTagName](#hydrolysis.Analyzer+elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
  76 + * [.features](#hydrolysis.Analyzer+features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
  77 + * [.behaviors](#hydrolysis.Analyzer+behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
  78 + * [.behaviorsByName](#hydrolysis.Analyzer+behaviorsByName) : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
  79 + * [.html](#hydrolysis.Analyzer+html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
  80 + * [.parsedDocuments](#hydrolysis.Analyzer+parsedDocuments) : <code>Object</code>
  81 + * [.parsedScripts](#hydrolysis.Analyzer+parsedScripts) : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
  82 + * [._content](#hydrolysis.Analyzer+_content) : <code>Object</code>
  83 + * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer+_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
  84 + * [.metadataTree(href)](#hydrolysis.Analyzer+metadataTree) ⇒ <code>Promise</code>
  85 + * [.getLoadedAst(href, [loaded])](#hydrolysis.Analyzer+getLoadedAst) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
  86 + * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkDocuments) ⇒ <code>Object</code>
  87 + * [.nodeWalkAllDocuments(predicate)](#hydrolysis.Analyzer+nodeWalkAllDocuments) ⇒ <code>Object</code>
  88 + * [.annotate()](#hydrolysis.Analyzer+annotate)
  89 + * [.clean()](#hydrolysis.Analyzer+clean)
78 90 * _static_
79 91 * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
80 92  
... ... @@ -88,38 +100,55 @@ A database of Polymer metadata defined in HTML
88 100 | attachAST | <code>boolean</code> | If true, attach a parse5 compliant AST |
89 101 | [loader] | <code>FileLoader</code> | An optional `FileLoader` used to load external resources |
90 102  
91   -<a name="hydrolysis.Analyzer#elements"></a>
  103 +<a name="hydrolysis.Analyzer+elements"></a>
92 104 #### analyzer.elements : <code>Array.&lt;ElementDescriptor&gt;</code>
93 105 A list of all elements the `Analyzer` has metadata for.
94 106  
95 107 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
96   -<a name="hydrolysis.Analyzer#elementsByTagName"></a>
  108 +<a name="hydrolysis.Analyzer+elementsByTagName"></a>
97 109 #### analyzer.elementsByTagName : <code>Object.&lt;string, ElementDescriptor&gt;</code>
98 110 A view into `elements`, keyed by tag name.
99 111  
100 112 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
101   -<a name="hydrolysis.Analyzer#features"></a>
  113 +<a name="hydrolysis.Analyzer+features"></a>
102 114 #### analyzer.features : <code>Array.&lt;FeatureDescriptor&gt;</code>
103 115 A list of API features added to `Polymer.Base` encountered by the
104 116 analyzer.
105 117  
106 118 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
107   -<a name="hydrolysis.Analyzer#behaviors"></a>
  119 +<a name="hydrolysis.Analyzer+behaviors"></a>
108 120 #### analyzer.behaviors : <code>Array.&lt;BehaviorDescriptor&gt;</code>
109 121 The behaviors collected by the analysis pass.
110 122  
111 123 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
112   -<a name="hydrolysis.Analyzer#html"></a>
  124 +<a name="hydrolysis.Analyzer+behaviorsByName"></a>
  125 +#### analyzer.behaviorsByName : <code>Object.&lt;string, BehaviorDescriptor&gt;</code>
  126 +The behaviors collected by the analysis pass by name.
  127 +
  128 +**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
  129 +<a name="hydrolysis.Analyzer+html"></a>
113 130 #### analyzer.html : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
114 131 A map, keyed by absolute path, of Document metadata.
115 132  
116 133 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
117   -<a name="hydrolysis.Analyzer#parsedDocuments"></a>
  134 +<a name="hydrolysis.Analyzer+parsedDocuments"></a>
118 135 #### analyzer.parsedDocuments : <code>Object</code>
119 136 A map, keyed by path, of HTML document ASTs.
120 137  
121 138 **Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
122   -<a name="hydrolysis.Analyzer#_getDependencies"></a>
  139 +<a name="hydrolysis.Analyzer+parsedScripts"></a>
  140 +#### analyzer.parsedScripts : <code>Object.&lt;string, Array.&lt;ParsedJS&gt;&gt;</code>
  141 +A map, keyed by path, of JS script ASTs.
  142 +
  143 +If the path is an HTML file with multiple scripts, the entry will be an array of scripts.
  144 +
  145 +**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
  146 +<a name="hydrolysis.Analyzer+_content"></a>
  147 +#### analyzer._content : <code>Object</code>
  148 +A map, keyed by path, of document content.
  149 +
  150 +**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>
  151 +<a name="hydrolysis.Analyzer+_getDependencies"></a>
123 152 #### analyzer._getDependencies(href, [found], [transitive]) ⇒ <code>Array.&lt;string&gt;</code>
124 153 List all the html dependencies for the document at `href`.
125 154  
... ... @@ -132,7 +161,7 @@ List all the html dependencies for the document at `href`.
132 161 | [found] | <code>Object.&lt;string, boolean&gt;</code> | An object keyed by URL of the already resolved dependencies. |
133 162 | [transitive] | <code>boolean</code> | Whether to load transitive dependencies. Defaults to true. |
134 163  
135   -<a name="hydrolysis.Analyzer#metadataTree"></a>
  164 +<a name="hydrolysis.Analyzer+metadataTree"></a>
136 165 #### analyzer.metadataTree(href) ⇒ <code>Promise</code>
137 166 Returns a promise that resolves to a POJO representation of the import
138 167 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.
143 172 | --- | --- | --- |
144 173 | href | <code>string</code> | the import to get metadata for. |
145 174  
146   -<a name="hydrolysis.Analyzer#nodeWalkDocuments"></a>
  175 +<a name="hydrolysis.Analyzer+getLoadedAst"></a>
  176 +#### analyzer.getLoadedAst(href, [loaded]) ⇒ <code>Promise.&lt;DocumentAST&gt;</code>
  177 +Returns a promise resolving to a form of the AST with all links replaced
  178 +with the document they link to. .css and .script files become &lt;style&gt; and
  179 +&lt;script&gt;, respectively.
  180 +
  181 +The elements in the loaded document are unmodified from their original
  182 +documents.
  183 +
  184 +**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>
  185 +
  186 +| Param | Type | Description |
  187 +| --- | --- | --- |
  188 +| href | <code>string</code> | The document to load. |
  189 +| [loaded] | <code>Object.&lt;string, boolean&gt;</code> | An object keyed by already loaded documents. |
  190 +
  191 +<a name="hydrolysis.Analyzer+nodeWalkDocuments"></a>
147 192 #### analyzer.nodeWalkDocuments(predicate) ⇒ <code>Object</code>
148   -Calls `dom5.nodeWalk` on each document that `Anayzler` has laoded.
  193 +Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.
  194 +
  195 +**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>
  196 +
  197 +| Param | Type | Description |
  198 +| --- | --- | --- |
  199 +| predicate | <code>Object</code> | A dom5 predicate. |
  200 +
  201 +<a name="hydrolysis.Analyzer+nodeWalkAllDocuments"></a>
  202 +#### analyzer.nodeWalkAllDocuments(predicate) ⇒ <code>Object</code>
  203 +Calls `dom5.nodeWalkAll` on each document that `Anayzler` has laoded.
149 204  
150 205 **Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>
151 206  
... ... @@ -153,12 +208,12 @@ Calls `dom5.nodeWalk` on each document that `Anayzler` has laoded.
153 208 | --- | --- | --- |
154 209 | predicate | <code>Object</code> | A dom5 predicate. |
155 210  
156   -<a name="hydrolysis.Analyzer#annotate"></a>
  211 +<a name="hydrolysis.Analyzer+annotate"></a>
157 212 #### analyzer.annotate()
158 213 Annotates all loaded metadata with its documentation.
159 214  
160 215 **Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>
161   -<a name="hydrolysis.Analyzer#clean"></a>
  216 +<a name="hydrolysis.Analyzer+clean"></a>
162 217 #### analyzer.clean()
163 218 Removes redundant properties from the collected descriptors.
164 219  
... ... @@ -185,14 +240,14 @@ In order to properly filter paths, `href` _must_ be an absolute URI.
185 240  
186 241 * [.FileLoader](#hydrolysis.FileLoader)
187 242 * [new FileLoader()](#new_hydrolysis.FileLoader_new)
188   - * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
189   - * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
  243 + * [.addResolver(resolver)](#hydrolysis.FileLoader+addResolver)
  244 + * [.request(url)](#hydrolysis.FileLoader+request) ⇒ <code>Promise.&lt;string&gt;</code>
190 245  
191 246 <a name="new_hydrolysis.FileLoader_new"></a>
192 247 #### new FileLoader()
193 248 A FileLoader lets you resolve URLs with a set of potential resolvers.
194 249  
195   -<a name="hydrolysis.FileLoader#addResolver"></a>
  250 +<a name="hydrolysis.FileLoader+addResolver"></a>
196 251 #### fileLoader.addResolver(resolver)
197 252 Add an instance of a Resolver class to the list of url resolvers
198 253  
... ... @@ -205,7 +260,7 @@ The first resolver to &quot;accept&quot; the url wins.
205 260 | --- | --- | --- |
206 261 | resolver | <code>Resolver</code> | The resolver to add. |
207 262  
208   -<a name="hydrolysis.FileLoader#request"></a>
  263 +<a name="hydrolysis.FileLoader+request"></a>
209 264 #### fileLoader.request(url) ⇒ <code>Promise.&lt;string&gt;</code>
210 265 Return a promise for an absolute url
211 266  
... ... @@ -241,7 +296,7 @@ Resolves requests via the file system.
241 296  
242 297 * [.NoopResolver](#hydrolysis.NoopResolver)
243 298 * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
244   - * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
  299 + * [.accept(uri, deferred)](#hydrolysis.NoopResolver+accept) ⇒ <code>boolean</code>
245 300  
246 301 <a name="new_hydrolysis.NoopResolver_new"></a>
247 302 #### new NoopResolver(config)
... ... @@ -252,7 +307,7 @@ A resolver that resolves to null any uri matching config.
252 307 | --- | --- | --- |
253 308 | config | <code>string</code> | The url to `accept`. |
254 309  
255   -<a name="hydrolysis.NoopResolver#accept"></a>
  310 +<a name="hydrolysis.NoopResolver+accept"></a>
256 311 #### noopResolver.accept(uri, deferred) ⇒ <code>boolean</code>
257 312 **Kind**: instance method of <code>[NoopResolver](#hydrolysis.NoopResolver)</code>
258 313 **Returns**: <code>boolean</code> - Whether the URI is handled by this resolver.
... ... @@ -280,6 +335,23 @@ Construct a resolver that requests resources over XHR.
280 335 Parse5's representation of a parsed html document
281 336  
282 337 **Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>
  338 +<a name="hydrolysis.JSAST"></a>
  339 +### hydrolysis.JSAST : <code>Object</code>
  340 +espree's representation of a parsed html document
  341 +
  342 +**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>
  343 +<a name="hydrolysis.ParsedJS"></a>
  344 +### hydrolysis.ParsedJS : <code>Object</code>
  345 +Package of a parsed JS script
  346 +
  347 +**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>
  348 +**Properties**
  349 +
  350 +| Name | Type | Description |
  351 +| --- | --- | --- |
  352 +| ast | <code>JSAST</code> | The script's AST |
  353 +| scriptElement | <code>DocumentAST</code> | If inline, the script's containing tag. |
  354 +
283 355 <a name="hydrolysis.ElementDescriptor"></a>
284 356 ### hydrolysis.ElementDescriptor : <code>Object</code>
285 357 The metadata for a single polymer element
... ...
bower_components/hydrolysis/LICENSE 100755 → 100644
bower_components/hydrolysis/README.md 100755 → 100644
1 1 # hydrolysis
2 2  
3   -Static anlaysis utilities for polymer.
  3 +Static analysis utilities for polymer.
4 4  
5 5 ## Install
6 6 ```
... ...
bower_components/hydrolysis/bower.json 100755 → 100644
... ... @@ -19,5 +19,5 @@
19 19 "webcomponentsjs": "webcomponents/webcomponentsjs#^0.7.0",
20 20 "web-component-tester": "*"
21 21 },
22   - "version": "1.15.1"
  22 + "version": "1.19.0"
23 23 }
... ...
bower_components/hydrolysis/hydrolysis-analyzer.html 100755 → 100644
bower_components/hydrolysis/hydrolysis.html 100755 → 100644
bower_components/hydrolysis/hydrolysis.js 100755 → 100644
... ... @@ -13,7 +13,6 @@ require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof requ
13 13 'use strict';
14 14 // jshint -W079
15 15 var Promise = global.Promise || require('es6-promise').Promise;
16   -require("setimmediate");
17 16 // jshint +W079
18 17  
19 18 var dom5 = require('dom5');
... ... @@ -42,6 +41,20 @@ var EMPTY_METADATA = {elements: [], features: [], behaviors: []};
42 41 */
43 42  
44 43 /**
  44 + * espree's representation of a parsed html document
  45 + * @typedef {Object} JSAST
  46 + * @memberof hydrolysis
  47 + */
  48 +
  49 +/**
  50 + * Package of a parsed JS script
  51 + * @typedef {Object} ParsedJS
  52 + * @property {JSAST} ast The script's AST
  53 + * @property {DocumentAST} scriptElement If inline, the script's containing tag.
  54 + * @memberof hydrolysis
  55 + */
  56 +
  57 +/**
45 58 * The metadata for a single polymer element
46 59 * @typedef {Object} ElementDescriptor
47 60 * @memberof hydrolysis
... ... @@ -125,13 +138,18 @@ var Analyzer = function Analyzer(attachAST,
125 138 this.behaviors = [];
126 139  
127 140 /**
  141 + * The behaviors collected by the analysis pass by name.
  142 + *
  143 + * @member {Object<string,BehaviorDescriptor>}
  144 + */
  145 + this.behaviorsByName = {};
  146 +
  147 + /**
128 148 * A map, keyed by absolute path, of Document metadata.
129 149 * @member {Object<string,AnalyzedDocument>}
130 150 */
131 151 this.html = {};
132 152  
133   - this._parsedDocuments = {};
134   -
135 153 /**
136 154 * A map, keyed by path, of HTML document ASTs.
137 155 * @type {Object}
... ... @@ -139,6 +157,17 @@ var Analyzer = function Analyzer(attachAST,
139 157 this.parsedDocuments = {};
140 158  
141 159 /**
  160 + * A map, keyed by path, of JS script ASTs.
  161 + *
  162 + * If the path is an HTML file with multiple scripts, the entry will be an array of scripts.
  163 + *
  164 + * @type {Object<string,Array<ParsedJS>>}
  165 + */
  166 + this.parsedScripts = {};
  167 +
  168 +
  169 +
  170 + /**
142 171 * A map, keyed by path, of document content.
143 172 * @type {Object}
144 173 */
... ... @@ -207,11 +236,14 @@ function _defaultFilter(href) {
207 236 Analyzer.prototype.load = function load(href) {
208 237 return this.loader.request(href).then(function(content) {
209 238 return new Promise(function(resolve, reject) {
210   - setImmediate(function() {
  239 + setTimeout(function() {
211 240 this._content[href] = content;
212 241 resolve(this._parseHTML(content, href));
213   - }.bind(this));
214   - }.bind(this));
  242 + }.bind(this), 0);
  243 + }.bind(this)).catch(function(err){
  244 + console.error("Error processing document at " + href);
  245 + throw err;
  246 + });
215 247 }.bind(this));
216 248 };
217 249  
... ... @@ -240,8 +272,26 @@ Analyzer.prototype._parseHTML = function _parseHTML(htmlImport,
240 272 var htmlLoaded = Promise.resolve(parsed);
241 273 if (parsed.script) {
242 274 metadataLoaded = this._processScripts(parsed.script, href);
243   - depsLoaded.push(metadataLoaded);
244 275 }
  276 + var commentText = parsed.comment.map(function(comment){
  277 + return dom5.getTextContent(comment);
  278 + });
  279 + var pseudoElements = docs.parsePseudoElements(commentText);
  280 + pseudoElements.forEach(function(element){
  281 + element.contentHref = href;
  282 + this.elements.push(element);
  283 + this.elementsByTagName[element.is] = element;
  284 + }.bind(this));
  285 + metadataLoaded = metadataLoaded.then(function(metadata){
  286 + var metadataEntry = {
  287 + elements: pseudoElements,
  288 + features: [],
  289 + behaviors: []
  290 + };
  291 + return [metadata, metadataEntry].reduce(reduceMetadata);
  292 + });
  293 + depsLoaded.push(metadataLoaded);
  294 +
245 295  
246 296 if (this.loader) {
247 297 var baseUri = href;
... ... @@ -278,7 +328,6 @@ Analyzer.prototype._parseHTML = function _parseHTML(htmlImport,
278 328 depsLoaded = Promise.all(depsLoaded)
279 329 .then(function() {return depHrefs;})
280 330 .catch(function(err) {throw err;});
281   - this._parsedDocuments[href] = parsed;
282 331 this.parsedDocuments[href] = parsed.ast;
283 332 this.html[href] = {
284 333 href: href,
... ... @@ -305,7 +354,7 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
305 354 var parsedJs;
306 355 if (!src) {
307 356 try {
308   - parsedJs = jsParse(script.childNodes[0].value);
  357 + parsedJs = jsParse((script.childNodes.length) ? script.childNodes[0].value : '');
309 358 } catch (err) {
310 359 // Figure out the correct line number for the error.
311 360 var line = 0;
... ... @@ -318,7 +367,7 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
318 367 col += err.column;
319 368 var message = "Error parsing script in " + href + " at " + line + ":" + col;
320 369 message += "\n" + err.description;
321   - throw new Error(message);
  370 + return Promise.reject(new Error(message));
322 371 }
323 372 if (parsedJs.elements) {
324 373 parsedJs.elements.forEach(function(element) {
... ... @@ -342,9 +391,22 @@ Analyzer.prototype._processScript = function _processScript(script, href) {
342 391 if (parsedJs.behaviors) {
343 392 parsedJs.behaviors.forEach(function(behavior){
344 393 behavior.contentHref = href;
345   - });
  394 + this.behaviorsByName[behavior.is] = behavior;
  395 + this.behaviorsByName[behavior.symbol] = behavior;
  396 + }.bind(this));
346 397 this.behaviors = this.behaviors.concat(parsedJs.behaviors);
347 398 }
  399 + if (!Object.hasOwnProperty.call(this.parsedScripts, href)) {
  400 + this.parsedScripts[href] = [];
  401 + }
  402 + var scriptElement;
  403 + if (script.__ownerDocument && script.__ownerDocument == href) {
  404 + scriptElement = script;
  405 + }
  406 + this.parsedScripts[href].push({
  407 + ast: parsedJs.parsedScript,
  408 + scriptElement: scriptElement
  409 + });
348 410 return parsedJs;
349 411 }
350 412 if (this.loader) {
... ... @@ -417,6 +479,38 @@ Analyzer.prototype._getDependencies = function _getDependencies(href, found, tra
417 479 });
418 480 };
419 481  
  482 +function matchesDocumentFolder(descriptor, href) {
  483 + if (!descriptor.contentHref) {
  484 + return false;
  485 + }
  486 + var descriptorDoc = url.parse(descriptor.contentHref);
  487 + if (!descriptorDoc || !descriptorDoc.pathname) {
  488 + return false;
  489 + }
  490 + var searchDoc = url.parse(href);
  491 + if (!searchDoc || !searchDoc.pathname) {
  492 + return false;
  493 + }
  494 + var searchPath = searchDoc.pathname;
  495 + var lastSlash = searchPath.lastIndexOf("/");
  496 + if (lastSlash > 0) {
  497 + searchPath = searchPath.slice(0, lastSlash);
  498 + }
  499 + return descriptorDoc.pathname.indexOf(searchPath) === 0;
  500 +}
  501 +
  502 +Analyzer.prototype.elementsForFolder = function elementsForFolder(href) {
  503 + return this.elements.filter(function(element){
  504 + return matchesDocumentFolder(element, href);
  505 + });
  506 +};
  507 +
  508 +Analyzer.prototype.behaviorsForFolder = function behaviorsForFolder(href) {
  509 + return this.behaviors.filter(function(behavior){
  510 + return matchesDocumentFolder(behavior, href);
  511 + });
  512 +};
  513 +
420 514 /**
421 515 * Returns a promise that resolves to a POJO representation of the import
422 516 * 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) {
545 639  
546 640 /**
547 641 * Returns a promise resolving to a form of the AST with all links replaced
548   - * with the document they link to. .css and .script files become <style> and
549   - * <script>, respectively.
  642 + * with the document they link to. .css and .script files become &lt;style&gt; and
  643 + * &lt;script&gt;, respectively.
550 644 *
551 645 * The elements in the loaded document are unmodified from their original
552 646 * documents.
553   - *
  647 + *
554 648 * @param {string} href The document to load.
555 649 * @param {Object.<string,boolean>=} loaded An object keyed by already loaded documents.
556 650 * @return {Promise.<DocumentAST>}
... ... @@ -560,9 +654,9 @@ Analyzer.prototype.getLoadedAst = function getLoadedAst(href, loaded) {
560 654 loaded = {};
561 655 }
562 656 loaded[href] = true;
563   - var document = this._parsedDocuments[href];
  657 + var parsedDocument = this.parsedDocuments[href];
564 658 var analyzedDocument = this.html[href];
565   - var astCopy = dom5.parse(dom5.serialize(document.ast));
  659 + var astCopy = dom5.parse(dom5.serialize(parsedDocument));
566 660 // Whenever we inline something, reset inlined to true to know that anoather
567 661 // inlining pass is needed;
568 662 this._inlineStyles(astCopy, href);
... ... @@ -577,8 +671,8 @@ Analyzer.prototype.getLoadedAst = function getLoadedAst(href, loaded) {
577 671 * @return {Object}
578 672 */
579 673 Analyzer.prototype.nodeWalkDocuments = function nodeWalkDocuments(predicate) {
580   - for (var href in this._parsedDocuments) {
581   - var match = dom5.nodeWalk(this._parsedDocuments[href].ast, predicate);
  674 + for (var href in this.parsedDocuments) {
  675 + var match = dom5.nodeWalk(this.parsedDocuments[href], predicate);
582 676 if (match) {
583 677 return match;
584 678 }
... ... @@ -593,8 +687,8 @@ Analyzer.prototype.nodeWalkDocuments = function nodeWalkDocuments(predicate) {
593 687 */
594 688 Analyzer.prototype.nodeWalkAllDocuments = function nodeWalkDocuments(predicate) {
595 689 var results = [];
596   - for (var href in this._parsedDocuments) {
597   - var newNodes = dom5.nodeWalkAll(this._parsedDocuments[href].ast, predicate);
  690 + for (var href in this.parsedDocuments) {
  691 + var newNodes = dom5.nodeWalkAll(this.parsedDocuments[href], predicate);
598 692 results = results.concat(newNodes);
599 693 }
600 694 return results;
... ... @@ -607,9 +701,17 @@ Analyzer.prototype.annotate = function annotate() {
607 701 this.elements.unshift(featureEl);
608 702 this.elementsByTagName[featureEl.is] = featureEl;
609 703 }
610   -
611   - this.elements.forEach(docs.annotateElement);
612   - this.behaviors.forEach(docs.annotateElement); // Same shape.
  704 + var behaviorsByName = this.behaviorsByName;
  705 + var elementHelper = function(descriptor){
  706 + docs.annotateElement(descriptor, behaviorsByName);
  707 + };
  708 + this.elements.forEach(elementHelper);
  709 + this.behaviors.forEach(elementHelper); // Same shape.
  710 + this.behaviors.forEach(function(behavior){
  711 + if (behavior.is !== behavior.symbol && behavior.symbol) {
  712 + this.behaviorsByName[behavior.symbol] = undefined;
  713 + }
  714 + }.bind(this));
613 715 };
614 716  
615 717 function attachDomModule(parsedImport, element) {
... ... @@ -631,8 +733,8 @@ Analyzer.prototype.clean = function clean() {
631 733 module.exports = Analyzer;
632 734  
633 735 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
634   -
635   -},{"./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){
  736 +//# 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"]}
  737 +},{"./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){
636 738 /**
637 739 * @license
638 740 * Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
... ... @@ -820,7 +922,7 @@ function arrayExpressionToValue(arry) {
820 922 for (var i=0; i<arry.elements.length; i++) {
821 923 var v = expressionToValue(arry.elements[i]);
822 924 if (v === undefined)
823   - v = CANT_CONVERT;
  925 + continue;
824 926 if (i !== 0)
825 927 value += ', ';
826 928 value += v;
... ... @@ -838,7 +940,7 @@ function objectExpressionToValue(obj) {
838 940 var k = expressionToValue(obj.properties[i].key);
839 941 var v = expressionToValue(obj.properties[i].value);
840 942 if (v === undefined)
841   - v = CANT_CONVERT;
  943 + continue;
842 944 if (i !== 0)
843 945 value += ', ';
844 946 value += '"' + k + '": ' + v;
... ... @@ -967,6 +1069,35 @@ module.exports = function behaviorFinder() {
967 1069 return newBehavior;
968 1070 }
969 1071  
  1072 + /**
  1073 + * gets the expression representing a behavior from a node.
  1074 + */
  1075 + function behaviorExpression(node) {
  1076 + switch(node.type) {
  1077 + case 'ExpressionStatement':
  1078 + return node.expression.right;
  1079 + case 'VariableDeclaration':
  1080 + return node.declarations.length > 0 ? node.declarations[0].init : null;
  1081 + }
  1082 + }
  1083 +
  1084 + /**
  1085 + * checks whether an expression is a simple array containing only member
  1086 + * expressions or identifiers.
  1087 + */
  1088 + function isSimpleBehaviorArray(expression) {
  1089 + if (!expression || expression.type !== 'ArrayExpression') return false;
  1090 + for (var i=0; i < expression.elements.length; i++) {
  1091 + if (expression.elements[i].type !== 'MemberExpression' &&
  1092 + expression.elements[i].type !== 'Identifier') {
  1093 + return false;
  1094 + }
  1095 + }
  1096 + return true;
  1097 + }
  1098 +
  1099 + var templatizer = "Polymer.Templatizer";
  1100 +
970 1101 var visitors = {
971 1102  
972 1103 /**
... ... @@ -993,20 +1124,14 @@ module.exports = function behaviorFinder() {
993 1124 // inside the array. Ex:
994 1125 // Polymer.IronMultiSelectableBehavior = [ {....}, Polymer.IronSelectableBehavior]
995 1126 // We add these to behaviors array
996   - var expression;
997   - switch(node.type) {
998   - case 'ExpressionStatement':
999   - expression = node.expression.right;
1000   - break;
1001   - case 'VariableDeclaration':
1002   - expression = node.declarations.length > 0 ? node.declarations[0].init : null;
1003   - break;
1004   - }
  1127 + var expression = behaviorExpression(node);
1005 1128 var chained = [];
1006 1129 if (expression && expression.type === 'ArrayExpression') {
1007 1130 for (var i=0; i < expression.elements.length; i++) {
1008   - if (expression.elements[i].type === 'MemberExpression')
  1131 + if (expression.elements[i].type === 'MemberExpression' ||
  1132 + expression.elements[i].type === 'Identifier') {
1009 1133 chained.push(astValue.expressionToValue(expression.elements[i]));
  1134 + }
1010 1135 }
1011 1136 if (chained.length > 0)
1012 1137 currentBehavior.behaviors = chained;
... ... @@ -1015,8 +1140,13 @@ module.exports = function behaviorFinder() {
1015 1140  
1016 1141 _initBehavior: function(node, getName) {
1017 1142 var comment = esutil.getAttachedComment(node);
  1143 + var symbol = getName();
1018 1144 // Quickly filter down to potential candidates.
1019   - if (!comment || comment.indexOf('@polymerBehavior') === -1) return;
  1145 + if (!comment || comment.indexOf('@polymerBehavior') === -1) {
  1146 + if (symbol !== templatizer) {
  1147 + return;
  1148 + }
  1149 + }
1020 1150  
1021 1151  
1022 1152 currentBehavior = {
... ... @@ -1029,14 +1159,16 @@ module.exports = function behaviorFinder() {
1029 1159  
1030 1160 docs.annotateBehavior(currentBehavior);
1031 1161 // Make sure that we actually parsed a behavior tag!
1032   - if (!jsdoc.hasTag(currentBehavior.jsdoc, 'polymerBehavior')) {
  1162 + if (!jsdoc.hasTag(currentBehavior.jsdoc, 'polymerBehavior') &&
  1163 + symbol !== templatizer) {
1033 1164 currentBehavior = null;
1034 1165 return;
1035 1166 }
1036 1167  
1037 1168 var name = jsdoc.getTag(currentBehavior.jsdoc, 'polymerBehavior', 'name');
  1169 + currentBehavior.symbol = symbol;
1038 1170 if (!name) {
1039   - name = getName();
  1171 + name = currentBehavior.symbol;
1040 1172 }
1041 1173 if (!name) {
1042 1174 console.warn('Unable to determine name for @polymerBehavior:', comment);
... ... @@ -1046,6 +1178,16 @@ module.exports = function behaviorFinder() {
1046 1178 this._parseChainedBehaviors(node);
1047 1179  
1048 1180 currentBehavior = mergeBehavior(currentBehavior);
  1181 +
  1182 + // Some behaviors are just lists of other behaviors. If this is one then
  1183 + // add it to behaviors right away.
  1184 + if (isSimpleBehaviorArray(behaviorExpression(node))) {
  1185 + // TODO(ajo): Add a test to confirm the presence of `properties`.
  1186 + if (!currentBehavior.properties) currentBehavior.properties = [];
  1187 + if (behaviors.indexOf(currentBehavior) === -1)
  1188 + behaviors.push(currentBehavior);
  1189 + currentBehavior = null;
  1190 + }
1049 1191 },
1050 1192  
1051 1193 /**
... ... @@ -1180,6 +1322,54 @@ function annotateElementHeader(descriptor) {
1180 1322 }
1181 1323 }
1182 1324  
  1325 +function matchByName(propa, propb) {
  1326 + return propa.name == propb.name;
  1327 +}
  1328 +
  1329 +function copyProperties(from, to, behaviorsByName) {
  1330 + if (from.properties) {
  1331 + from.properties.forEach(function(fromProp){
  1332 + for (var toProp, i = 0; i < to.properties.length; i++) {
  1333 + toProp = to.properties[i];
  1334 + if (fromProp.name === toProp.name) {
  1335 + return;
  1336 + }
  1337 + }
  1338 + var newProp = {__fromBehavior: from.is};
  1339 + if (fromProp.__fromBehavior) {
  1340 + return;
  1341 + }
  1342 + Object.keys(fromProp).forEach(function(propertyField){
  1343 + newProp[propertyField] = fromProp[propertyField];
  1344 + });
  1345 + to.properties.push(newProp);
  1346 + });
  1347 + }
  1348 + if (!from.behaviors) {
  1349 + return;
  1350 + }
  1351 + from.behaviors.forEach(function(behavior){
  1352 + var definedBehavior = behaviorsByName[behavior] || behaviorsByName[behavior.symbol];
  1353 + if (!definedBehavior) {
  1354 + return;
  1355 + }
  1356 + copyProperties(definedBehavior, to, behaviorsByName);
  1357 + });
  1358 +}
  1359 +
  1360 +function mixinBehaviors(descriptor, behaviorsByName) {
  1361 + if (descriptor.behaviors) {
  1362 + descriptor.behaviors.forEach(function(behavior){
  1363 + if (!behaviorsByName[behavior]) {
  1364 + console.warn("Behavior " + behavior + " not found!");
  1365 + return;
  1366 + }
  1367 + var definedBehavior = behaviorsByName[behavior];
  1368 + copyProperties(definedBehavior, descriptor, behaviorsByName);
  1369 + });
  1370 + }
  1371 +}
  1372 +
1183 1373 /**
1184 1374 * Annotates documentation found within a Hydrolysis element descriptor. Also
1185 1375 * supports behaviors.
... ... @@ -1190,7 +1380,7 @@ function annotateElementHeader(descriptor) {
1190 1380 * @param {Object} descriptor The element descriptor.
1191 1381 * @return {Object} The descriptor that was given.
1192 1382 */
1193   -function annotateElement(descriptor) {
  1383 +function annotateElement(descriptor, behaviorsByName) {
1194 1384 if (!descriptor.desc && descriptor.type === 'element') {
1195 1385 descriptor.desc = _findElementDocs(descriptor.is,
1196 1386 descriptor.domModule,
... ... @@ -1201,8 +1391,11 @@ function annotateElement(descriptor) {
1201 1391 // The `<dom-module>` is too low level for most needs, and it is _not_
1202 1392 // serializable. So we drop it now that we've extracted all the useful bits
1203 1393 // from it.
  1394 + // TODO: Don't worry about serializability here, provide an API to get JSON.
1204 1395 delete descriptor.domModule;
1205 1396  
  1397 + mixinBehaviors(descriptor, behaviorsByName);
  1398 +
1206 1399 // Descriptors that should have their `desc` properties parsed as JSDoc.
1207 1400 descriptor.properties.forEach(function(property) {
1208 1401 // Feature properties are special, configuration is really just a matter of
... ... @@ -1235,9 +1428,8 @@ function annotateElement(descriptor) {
1235 1428 * @param {Object} descriptor behavior descriptor
1236 1429 * @return {Object} descriptor passed in as param
1237 1430 */
1238   -function annotateBehavior(descriptor) {
  1431 +function annotateBehavior(descriptor, behaviorsByName) {
1239 1432 annotate(descriptor);
1240   -
1241 1433 annotateElementHeader(descriptor);
1242 1434  
1243 1435 return descriptor;
... ... @@ -1296,7 +1488,10 @@ function annotateProperty(descriptor, ignoreConfiguration) {
1296 1488 // @default JSDoc wins
1297 1489 var defaultTag = jsdoc.getTag(descriptor.jsdoc, 'default');
1298 1490 if (defaultTag !== null) {
1299   - descriptor.default = (defaultTag.name || '') + (defaultTag.description || '');
  1491 + var newDefault = (defaultTag.name || '') + (defaultTag.description || '');
  1492 + if (newDefault !== '') {
  1493 + descriptor.default = newDefault;
  1494 + }
1300 1495 }
1301 1496  
1302 1497 return descriptor;
... ... @@ -1408,6 +1603,30 @@ function cleanProperty(property) {
1408 1603 }
1409 1604  
1410 1605 /**
  1606 + * Parse elements defined only in comments.
  1607 + * @param {comments} Array<string> A list of comments to parse.
  1608 + * @return {ElementDescriptor} A list of pseudo-elements.
  1609 + */
  1610 +function parsePseudoElements(comments) {
  1611 + var elements = [];
  1612 + comments.forEach(function(comment) {
  1613 + var parsed = jsdoc.parseJsdoc(comment);
  1614 + var pseudoTag = jsdoc.getTag(parsed, 'pseudoElement', 'name');
  1615 + if (pseudoTag) {
  1616 + parsed.is = pseudoTag;
  1617 + parsed.jsdoc = {description: parsed.description, tags: parsed.tags};
  1618 + parsed.properties = [];
  1619 + parsed.desc = parsed.description;
  1620 + parsed.description = undefined;
  1621 + parsed.tags = undefined;
  1622 + annotateElementHeader(parsed);
  1623 + elements.push(parsed);
  1624 + }
  1625 + });
  1626 + return elements;
  1627 +}
  1628 +
  1629 +/**
1411 1630 * @param {string} elementId
1412 1631 * @param {DocumentAST} domModule
1413 1632 * @param {DocumentAST} scriptElement The script that the element was defined in.
... ... @@ -1470,6 +1689,7 @@ module.exports = {
1470 1689 clean: clean,
1471 1690 cleanElement: cleanElement,
1472 1691 featureElement: featureElement,
  1692 + parsePseudoElements: parsePseudoElements
1473 1693 };
1474 1694  
1475 1695 },{"./jsdoc":12,"dom5":38}],6:[function(require,module,exports){
... ... @@ -1525,7 +1745,6 @@ var elementFinder = function elementFinder() {
1525 1745 if (node.type != 'ArrayExpression') {
1526 1746 return;
1527 1747 }
1528   - element.behaviors = [];
1529 1748  
1530 1749 for (var i=0; i<node.elements.length; i++) {
1531 1750 var v = astValue.expressionToValue(node.elements[i]);
... ... @@ -1566,6 +1785,7 @@ var elementFinder = function elementFinder() {
1566 1785 enterObjectExpression: function enterObjectExpression(node, parent) {
1567 1786 if (element && !element.properties) {
1568 1787 element.properties = [];
  1788 + element.behaviors = [];
1569 1789 for (var i = 0; i < node.properties.length; i++) {
1570 1790 var prop = node.properties[i];
1571 1791 var name = esutil.objectKeyToString(prop.key);
... ... @@ -1883,13 +2103,30 @@ var isStyleNode = p.OR(
1883 2103 )
1884 2104 );
1885 2105  
  2106 +var isJSScriptNode = p.AND(
  2107 + p.hasTagName('script'),
  2108 + p.OR(
  2109 + p.NOT(p.hasAttr('type')),
  2110 + p.hasAttrValue('type', 'text/javascript'),
  2111 + p.hasAttrValue('type', 'application/javascript')
  2112 + )
  2113 +);
  2114 +
1886 2115 function addNode(node, registry) {
1887 2116 if (isHtmlImportNode(node)) {
1888 2117 registry.import.push(node);
1889 2118 } else if (isStyleNode(node)) {
1890 2119 registry.style.push(node);
1891   - } else if (registry.hasOwnProperty(node.tagName)) {
1892   - registry[node.tagName].push(node);
  2120 + } else if (isJSScriptNode(node)) {
  2121 + registry.script.push(node);
  2122 + } else if (node.tagName === 'base') {
  2123 + registry.base.push(node);
  2124 + } else if (node.tagName === 'template') {
  2125 + registry.template.push(node);
  2126 + } else if (node.tagName === 'dom-module') {
  2127 + registry['dom-module'].push(node);
  2128 + } else if (dom5.isCommentNode(node)) {
  2129 + registry.comment.push(node);
1893 2130 }
1894 2131 }
1895 2132  
... ... @@ -1951,13 +2188,14 @@ var importParse = function importParse(htmlString, href) {
1951 2188 script: [],
1952 2189 style: [],
1953 2190 import: [],
1954   - 'dom-module': []};
  2191 + 'dom-module': [],
  2192 + comment: []};
1955 2193  
1956 2194 var queue = [].concat(doc.childNodes);
1957 2195 var nextNode;
1958 2196 while (queue.length > 0) {
1959 2197 nextNode = queue.shift();
1960   - if (nextNode && nextNode.tagName) {
  2198 + if (nextNode) {
1961 2199 queue = queue.concat(nextNode.childNodes);
1962 2200 addNode(nextNode, registry);
1963 2201 }
... ... @@ -2058,6 +2296,7 @@ var jsParse = function jsParse(jsString) {
2058 2296 behaviors: behaviorInfo.behaviors,
2059 2297 elements: elementInfo.elements,
2060 2298 features: featureInfo.features,
  2299 + parsedScript: script
2061 2300 };
2062 2301 };
2063 2302  
... ... @@ -2376,7 +2615,7 @@ FileLoader.prototype = {
2376 2615 }
2377 2616  
2378 2617 if (!handled) {
2379   - deferred.reject('no resolver found');
  2618 + deferred.reject(new Error('no resolver found for ' + uri));
2380 2619 }
2381 2620  
2382 2621 promise = deferred.promise;
... ... @@ -2391,7 +2630,7 @@ FileLoader.prototype = {
2391 2630 module.exports = FileLoader;
2392 2631  
2393 2632 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
2394   -
  2633 +//# sourceMappingURL=data:application/json;charset:utf-8;base64,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
2395 2634 },{"es6-promise":60}],14:[function(require,module,exports){
2396 2635 /**
2397 2636 * @license
... ... @@ -3221,7 +3460,7 @@ var substr = &#39;ab&#39;.substr(-1) === &#39;b&#39;
3221 3460 ;
3222 3461  
3223 3462 }).call(this,require('_process'))
3224   -
  3463 +//# 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"]}
3225 3464 },{"_process":21}],21:[function(require,module,exports){
3226 3465 // shim for using process in browser
3227 3466  
... ... @@ -3793,7 +4032,7 @@ process.umask = function() { return 0; };
3793 4032 }(this));
3794 4033  
3795 4034 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
3796   -
  4035 +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/punycode/punycode.js"],"names":[],"mappings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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"]}
3797 4036 },{}],23:[function(require,module,exports){
3798 4037 // Copyright Joyent, Inc. and other Node contributors.
3799 4038 //
... ... @@ -5279,7 +5518,7 @@ function hasOwnProperty(obj, prop) {
5279 5518 }
5280 5519  
5281 5520 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
5282   -
  5521 +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/util/util.js"],"names":[],"mappings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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"]}
5283 5522 },{"./support/isBuffer":27,"_process":21,"inherits":19}],29:[function(require,module,exports){
5284 5523 /*
5285 5524 Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
... ... @@ -5607,6 +5846,10 @@ function hasOwnProperty(obj, prop) {
5607 5846 name += scanIdentifier(last);
5608 5847  
5609 5848 }
  5849 + if(source.charCodeAt(index) === 0x5B /* '[' */ && source.charCodeAt(index + 1) === 0x5D /* ']' */){
  5850 + name += advance();
  5851 + name += advance();
  5852 + }
5610 5853 while (source.charCodeAt(index) === 0x2E /* '.' */ ||
5611 5854 source.charCodeAt(index) === 0x23 /* '#' */ ||
5612 5855 source.charCodeAt(index) === 0x7E /* '~' */) {
... ... @@ -5864,7 +6107,9 @@ function hasOwnProperty(obj, prop) {
5864 6107 // un-fix potentially sloppy declaration
5865 6108 if (isParamTitle(this._title) && !this._tag.type && description && description.charAt(0) === '[') {
5866 6109 this._tag.type = this._extra.name;
5867   - this._tag.name = undefined;
  6110 + if (!this._tag.name) {
  6111 + this._tag.name = undefined;
  6112 + }
5868 6113  
5869 6114 if (!sloppy) {
5870 6115 if (!this.addError('Missing or invalid tag name')) {
... ... @@ -7847,7 +8092,7 @@ module.exports={
7847 8092 "description": "JSDoc parser",
7848 8093 "homepage": "http://github.com/Constellation/doctrine.html",
7849 8094 "main": "lib/doctrine.js",
7850   - "version": "0.6.4",
  8095 + "version": "0.7.0",
7851 8096 "engines": {
7852 8097 "node": ">=0.10.0"
7853 8098 },
... ... @@ -7863,14 +8108,17 @@ module.exports={
7863 8108 ],
7864 8109 "maintainers": [
7865 8110 {
7866   - "name": "Yusuke Suzuki",
7867   - "email": "utatane.tea@gmail.com",
7868   - "url": "http://github.com/Constellation"
  8111 + "name": "constellation",
  8112 + "email": "utatane.tea@gmail.com"
  8113 + },
  8114 + {
  8115 + "name": "nzakas",
  8116 + "email": "nicholas@nczconsulting.com"
7869 8117 }
7870 8118 ],
7871 8119 "repository": {
7872 8120 "type": "git",
7873   - "url": "http://github.com/Constellation/doctrine.git"
  8121 + "url": "http://github.com/eslint/doctrine.git"
7874 8122 },
7875 8123 "devDependencies": {
7876 8124 "coveralls": "^2.11.2",
... ... @@ -7889,7 +8137,7 @@ module.exports={
7889 8137 "licenses": [
7890 8138 {
7891 8139 "type": "BSD",
7892   - "url": "http://github.com/Constellation/doctrine/raw/master/LICENSE.BSD"
  8140 + "url": "http://github.com/eslint/doctrine/raw/master/LICENSE.BSD"
7893 8141 }
7894 8142 ],
7895 8143 "scripts": {
... ... @@ -7902,17 +8150,23 @@ module.exports={
7902 8150 "esutils": "^1.1.6",
7903 8151 "isarray": "0.0.1"
7904 8152 },
7905   - "gitHead": "4f74c86ea5cd03fbd947c4df91a2192d13779fb5",
7906   - "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",
7907   - "readmeFilename": "README.md",
  8153 + "gitHead": "0d059e422bdfd630eaa15d583567c8668923f7e6",
7908 8154 "bugs": {
7909   - "url": "https://github.com/Constellation/doctrine/issues"
  8155 + "url": "https://github.com/eslint/doctrine/issues"
  8156 + },
  8157 + "_id": "doctrine@0.7.0",
  8158 + "_shasum": "dcc9589850b043d6e58abe24b561ccd57176cfd3",
  8159 + "_from": "doctrine@*",
  8160 + "_npmVersion": "1.4.28",
  8161 + "_npmUser": {
  8162 + "name": "nzakas",
  8163 + "email": "nicholas@nczconsulting.com"
  8164 + },
  8165 + "dist": {
  8166 + "shasum": "dcc9589850b043d6e58abe24b561ccd57176cfd3",
  8167 + "tarball": "http://registry.npmjs.org/doctrine/-/doctrine-0.7.0.tgz"
7910 8168 },
7911   - "_id": "doctrine@0.6.4",
7912   - "_shasum": "5b8d534412b49b8177b52082cd95df380de390aa",
7913   - "_from": "git://github.com/PolymerLabs/doctrine.git#master",
7914   - "_resolved": "git://github.com/PolymerLabs/doctrine.git#4f74c86ea5cd03fbd947c4df91a2192d13779fb5",
7915   - "_fromGithub": true
  8169 + "_resolved": "https://registry.npmjs.org/doctrine/-/doctrine-0.7.0.tgz"
7916 8170 }
7917 8171  
7918 8172 },{}],38:[function(require,module,exports){
... ... @@ -8273,6 +8527,34 @@ function _reverseNodeWalkAll(node, predicate, matches) {
8273 8527 }
8274 8528  
8275 8529 /**
  8530 + * Equivalent to `nodeWalk`, but only returns nodes that are either
  8531 + * ancestors or earlier cousins/siblings in the document.
  8532 + *
  8533 + * Nodes are searched in reverse document order, starting from the sibling
  8534 + * prior to `node`.
  8535 + */
  8536 +function nodeWalkPrior(node, predicate) {
  8537 + // Search our earlier siblings and their descendents.
  8538 + var parent = node.parentNode;
  8539 + if (parent) {
  8540 + var idx = parent.childNodes.indexOf(node);
  8541 + var siblings = parent.childNodes.slice(0, idx);
  8542 + for (var i = siblings.length-1; i >= 0; i--) {
  8543 + var sibling = siblings[i];
  8544 + if (predicate(sibling)) {
  8545 + return sibling;
  8546 + }
  8547 + var found = nodeWalkPrior(sibling, predicate);
  8548 + }
  8549 + if (predicate(parent)) {
  8550 + return parent;
  8551 + }
  8552 + return nodeWalkPrior(parent, predicate);
  8553 + }
  8554 + return undefined;
  8555 +}
  8556 +
  8557 +/**
8276 8558 * Equivalent to `nodeWalkAll`, but only returns nodes that are either
8277 8559 * ancestors or earlier cousins/siblings in the document.
8278 8560 *
... ... @@ -8409,6 +8691,7 @@ module.exports = {
8409 8691 queryAll: queryAll,
8410 8692 nodeWalk: nodeWalk,