diff --git a/html/team2/Reported_By_Gender_Count/.DS_Store b/html/team2/Reported_By_Gender_Count/.DS_Store
new file mode 100644
index 0000000..176e6a0
Binary files /dev/null and b/html/team2/Reported_By_Gender_Count/.DS_Store differ
diff --git a/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count.tsv b/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count.tsv
new file mode 100644
index 0000000..d13593e
--- /dev/null
+++ b/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count.tsv
@@ -0,0 +1 @@
+Year Male Female Adult Not_Adult
1991 36 0 37 0
1992 36 5 41 2
1993 51 1 52 1
1994 71 4 75 1
1995 115 205 320 9
1996 174 41 218 5
1997 171 12 188 5
1998 185 11 199 4
1999 307 13 323 9
2000 311 17 333 3
2001 336 8 352 4
2002 334 6 343 8
2003 456 12 474 8
2004 451 8 464 9
2005 431 12 446 8
2006 362 8 374 2
2007 409 12 427 7
2008 492 13 513 8
2009 414 10 433 9
2010 246 5 255 3
\ No newline at end of file
diff --git a/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count_total.csv b/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count_total.csv
new file mode 100644
index 0000000..aca9c5b
--- /dev/null
+++ b/html/team2/Reported_By_Gender_Count/ReportedBy_Male_Female_Adult_kid_year_count_total.csv
@@ -0,0 +1,5 @@
+Type,Count
+Male,5388
+Female,403
+Adult,5867
+Not_Adult,105
diff --git a/html/team2/Reported_By_Gender_Count/pie_chart.html b/html/team2/Reported_By_Gender_Count/pie_chart.html
new file mode 100644
index 0000000..41f6d21
--- /dev/null
+++ b/html/team2/Reported_By_Gender_Count/pie_chart.html
@@ -0,0 +1,66 @@
+
+
+Count of UFO sightings reported on gender basis and on Adult vs Non-Adult basis by year
+We have aggregated the data based on gender and age by utilizing the description which mentions "a Male reported", or "a Female reported" or "2 kids reported" etc. Both male and female categories are merged into Adult Category.
+Please note the data covered is 9.1 percent of the whole data.
+
+Count of UFO sightings reported by year
+This visualization helps us understand the rate of growth of UFO sightings reported per year.
+
+
+Count of UFO sightings reported within 25 miles of the nearest Airport or otherwise, by year
+Aggregation on the joined dataset - UFO Sightings with nearest Airport location (within 25 miles) to the Sighting location.
+
+
+ Outside 25 miles
+ Within 25 miles
+
+
+
+
\ No newline at end of file
diff --git a/html/team2/dense_sparse_count/.DS_Store b/html/team2/dense_sparse_count/.DS_Store
new file mode 100644
index 0000000..a8558cd
Binary files /dev/null and b/html/team2/dense_sparse_count/.DS_Store differ
diff --git a/html/team2/dense_sparse_count/3D_Donut.html b/html/team2/dense_sparse_count/3D_Donut.html
new file mode 100644
index 0000000..1b363c0
--- /dev/null
+++ b/html/team2/dense_sparse_count/3D_Donut.html
@@ -0,0 +1,88 @@
+
+UFO sightings : Densely populated areas vs Sparsely populated areas based on year
+This visualization has side to side comparision of the UFO Sightings that happened in densely populated areas vs sparsely populated areas based on year.
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/html/team2/dense_sparse_count/Donut3D.js b/html/team2/dense_sparse_count/Donut3D.js
new file mode 100644
index 0000000..76f3863
--- /dev/null
+++ b/html/team2/dense_sparse_count/Donut3D.js
@@ -0,0 +1,127 @@
+!function(){
+ var Donut3D={};
+
+ function pieTop(d, rx, ry, ir ){
+ if(d.endAngle - d.startAngle == 0 ) return "M 0 0";
+ var sx = rx*Math.cos(d.startAngle),
+ sy = ry*Math.sin(d.startAngle),
+ ex = rx*Math.cos(d.endAngle),
+ ey = ry*Math.sin(d.endAngle);
+
+ var ret =[];
+ ret.push("M",sx,sy,"A",rx,ry,"0",(d.endAngle-d.startAngle > Math.PI? 1: 0),"1",ex,ey,"L",ir*ex,ir*ey);
+ ret.push("A",ir*rx,ir*ry,"0",(d.endAngle-d.startAngle > Math.PI? 1: 0), "0",ir*sx,ir*sy,"z");
+ return ret.join(" ");
+ }
+
+ function pieOuter(d, rx, ry, h ){
+ var startAngle = (d.startAngle > Math.PI ? Math.PI : d.startAngle);
+ var endAngle = (d.endAngle > Math.PI ? Math.PI : d.endAngle);
+
+ var sx = rx*Math.cos(startAngle),
+ sy = ry*Math.sin(startAngle),
+ ex = rx*Math.cos(endAngle),
+ ey = ry*Math.sin(endAngle);
+
+ var ret =[];
+ ret.push("M",sx,h+sy,"A",rx,ry,"0 0 1",ex,h+ey,"L",ex,ey,"A",rx,ry,"0 0 0",sx,sy,"z");
+ return ret.join(" ");
+ }
+
+ function pieInner(d, rx, ry, h, ir ){
+ var startAngle = (d.startAngle < Math.PI ? Math.PI : d.startAngle);
+ var endAngle = (d.endAngle < Math.PI ? Math.PI : d.endAngle);
+
+ var sx = ir*rx*Math.cos(startAngle),
+ sy = ir*ry*Math.sin(startAngle),
+ ex = ir*rx*Math.cos(endAngle),
+ ey = ir*ry*Math.sin(endAngle);
+
+ var ret =[];
+ ret.push("M",sx, sy,"A",ir*rx,ir*ry,"0 0 1",ex,ey, "L",ex,h+ey,"A",ir*rx, ir*ry,"0 0 0",sx,h+sy,"z");
+ return ret.join(" ");
+ }
+
+ function getPercent(d){
+ return (d.endAngle-d.startAngle > 0.2 ?
+ d.data.label + "->" + Math.round(1000*(d.endAngle-d.startAngle)/(Math.PI*2))/10+'%' : '');
+ }
+
+ function getID(d){
+ return (getPercent(d));
+ }
+
+ Donut3D.transition = function(id, data, rx, ry, h, ir){
+ function arcTweenInner(a) {
+ var i = d3.interpolate(this._current, a);
+ this._current = i(0);
+ return function(t) { return pieInner(i(t), rx+0.5, ry+0.5, h, ir); };
+ }
+ function arcTweenTop(a) {
+ var i = d3.interpolate(this._current, a);
+ this._current = i(0);
+ return function(t) { return pieTop(i(t), rx, ry, ir); };
+ }
+ function arcTweenOuter(a) {
+ var i = d3.interpolate(this._current, a);
+ this._current = i(0);
+ return function(t) { return pieOuter(i(t), rx-.5, ry-.5, h); };
+ }
+ function textTweenX(a) {
+ var i = d3.interpolate(this._current, a);
+ this._current = i(0);
+ return function(t) { return 0.6*rx*Math.cos(0.5*(i(t).startAngle+i(t).endAngle)); };
+ }
+ function textTweenY(a) {
+ var i = d3.interpolate(this._current, a);
+ this._current = i(0);
+ return function(t) { return 0.6*rx*Math.sin(0.5*(i(t).startAngle+i(t).endAngle)); };
+ }
+
+ var _data = d3.layout.pie().sort(null).value(function(d) {return d.value;})(data);
+
+ d3.select("#"+id).selectAll(".innerSlice").data(_data)
+ .transition().duration(750).attrTween("d", arcTweenInner);
+
+ d3.select("#"+id).selectAll(".topSlice").data(_data)
+ .transition().duration(750).attrTween("d", arcTweenTop);
+
+ d3.select("#"+id).selectAll(".outerSlice").data(_data)
+ .transition().duration(750).attrTween("d", arcTweenOuter);
+
+ d3.select("#"+id).selectAll(".percent").data(_data).transition().duration(750)
+ .attrTween("x",textTweenX).attrTween("y",textTweenY).text(getPercent);
+ }
+
+ Donut3D.draw=function(id, data, x /*center x*/, y/*center y*/,
+ rx/*radius x*/, ry/*radius y*/, h/*height*/, ir/*inner radius*/){
+
+ var _data = d3.layout.pie().sort(null).value(function(d) {return d.value;})(data);
+
+ var slices = d3.select("#"+id).append("g").attr("transform", "translate(" + x + "," + y + ")")
+ .attr("class", "slices");
+
+ slices.selectAll(".innerSlice").data(_data).enter().append("path").attr("class", "innerSlice")
+ .style("fill", function(d) { return d3.hsl(d.data.color).darker(0.7); })
+ .attr("d",function(d){ return pieInner(d, rx+0.5,ry+0.5, h, ir);})
+ .each(function(d){this._current=d;});
+
+ slices.selectAll(".topSlice").data(_data).enter().append("path").attr("class", "topSlice")
+ .style("fill", function(d) { return d.data.color; })
+ .style("stroke", function(d) { return d.data.color; })
+ .attr("d",function(d){ return pieTop(d, rx, ry, ir);})
+ .each(function(d){this._current=d;});
+
+ slices.selectAll(".outerSlice").data(_data).enter().append("path").attr("class", "outerSlice")
+ .style("fill", function(d) { return d3.hsl(d.data.color).darker(0.7); })
+ .attr("d",function(d){ return pieOuter(d, rx-.5,ry-.5, h);})
+ .each(function(d){this._current=d;});
+
+ slices.selectAll(".percent").data(_data).enter().append("text").attr("class", "percent")
+ .attr("x",function(d){ return 0.6*rx*Math.cos(0.5*(d.startAngle+d.endAngle));})
+ .attr("y",function(d){ return 0.6*ry*Math.sin(0.5*(d.startAngle+d.endAngle));})
+ .text(getPercent).each(function(d){this._current=d;});
+ }
+
+ this.Donut3D = Donut3D;
+}();
\ No newline at end of file
diff --git a/html/team2/dense_sparse_count/Population_dense_sparse_year_count.tsv b/html/team2/dense_sparse_count/Population_dense_sparse_year_count.tsv
new file mode 100644
index 0000000..9f30c1d
--- /dev/null
+++ b/html/team2/dense_sparse_count/Population_dense_sparse_year_count.tsv
@@ -0,0 +1,21 @@
+Year Dense Sparse
+1995 180 888
+1994 50 237
+1993 42 174
+1992 33 134
+1996 124 525
+1997 157 775
+1998 246 1152
+1991 36 119
+1999 454 1737
+2000 442 1749
+2001 594 1884
+2002 601 1873
+2003 767 2218
+2004 914 2380
+2005 839 2369
+2006 702 2163
+2007 860 2551
+2008 1025 2906
+2009 894 2669
+2010 505 1612
diff --git a/html/team2/dense_sparse_count/population.json b/html/team2/dense_sparse_count/population.json
new file mode 100644
index 0000000..f874996
--- /dev/null
+++ b/html/team2/dense_sparse_count/population.json
@@ -0,0 +1 @@
+{"Data": [{"Dense": [{"Year": "1995", "Dense": 180}, {"Year": "1994", "Dense": 50}, {"Year": "1993", "Dense": 42}, {"Year": "1992", "Dense": 33}, {"Year": "1996", "Dense": 124}, {"Year": "1997", "Dense": 157}, {"Year": "1998", "Dense": 246}, {"Year": "1991", "Dense": 36}, {"Year": "1999", "Dense": 454}, {"Year": "2000", "Dense": 442}, {"Year": "2001", "Dense": 594}, {"Year": "2002", "Dense": 601}, {"Year": "2003", "Dense": 767}, {"Year": "2004", "Dense": 914}, {"Year": "2005", "Dense": 839}, {"Year": "2006", "Dense": 702}, {"Year": "2007", "Dense": 860}, {"Year": "2008", "Dense": 1025}, {"Year": "2009", "Dense": 894}, {"Year": "2010", "Dense": 505}]}, {"Sparse": [{"Year": "1995", "Sparse": 888}, {"Year": "1994", "Sparse": 237}, {"Year": "1993", "Sparse": 174}, {"Year": "1992", "Sparse": 134}, {"Year": "1996", "Sparse": 525}, {"Year": "1997", "Sparse": 775}, {"Year": "1998", "Sparse": 1152}, {"Year": "1991", "Sparse": 119}, {"Year": "1999", "Sparse": 1737}, {"Year": "2000", "Sparse": 1749}, {"Year": "2001", "Sparse": 1884}, {"Year": "2002", "Sparse": 1873}, {"Year": "2003", "Sparse": 2218}, {"Year": "2004", "Sparse": 2380}, {"Year": "2005", "Sparse": 2369}, {"Year": "2006", "Sparse": 2163}, {"Year": "2007", "Sparse": 2551}, {"Year": "2008", "Sparse": 2906}, {"Year": "2009", "Sparse": 2669}, {"Year": "2010", "Sparse": 1612}]}]}
\ No newline at end of file
diff --git a/html/team2/dense_sparse_count/tsv_to_json.py b/html/team2/dense_sparse_count/tsv_to_json.py
new file mode 100644
index 0000000..bd76f15
--- /dev/null
+++ b/html/team2/dense_sparse_count/tsv_to_json.py
@@ -0,0 +1,29 @@
+import json
+
+dense={}
+sparse={}
+data = {}
+count = 1
+
+# Read Population_dense_sparse_count.tsv, and create two jsons Dense and Sparse
+with open("Population_dense_sparse_year_count.tsv","r", encoding = "ISO-8859-1") as f:
+ for line in f:
+ if count == 1:
+ count = count + 1
+ continue
+ sp=line.split("\t")
+
+ if len(sp) < 3:
+ continue
+ # print(len(sp))
+ dense.setdefault("Dense", []).append({"Year": sp[0], "Dense": int(sp[1].strip())})
+ sparse.setdefault("Sparse", []).append({"Year": sp[0], "Sparse": int(sp[2].strip())})
+
+data.setdefault("Data", []).append(dense)
+data.setdefault("Data", []).append(sparse)
+
+print(data)
+
+
+with open('population.json', 'w') as outfile:
+ json.dump(data, outfile)
diff --git a/html/team2/duration_year_count/.DS_Store b/html/team2/duration_year_count/.DS_Store
new file mode 100644
index 0000000..dcee00a
Binary files /dev/null and b/html/team2/duration_year_count/.DS_Store differ
diff --git a/html/team2/duration_year_count/data.tsv b/html/team2/duration_year_count/data.tsv
new file mode 100644
index 0000000..5a46b32
--- /dev/null
+++ b/html/team2/duration_year_count/data.tsv
@@ -0,0 +1,102 @@
+Year Secs Minutes Hours Days NoDuration
+1762 0 0 0 0 0
+1790 0 0 0 0 0
+1830 0 2 0 0 0
+1860 0 1 0 0 0
+1864 0 0 0 0 0
+1865 0 0 0 0 1
+1871 0 0 0 0 0
+1880 0 0 0 0 0
+1896 0 0 0 0 0
+1897 0 0 0 0 1
+1899 0 0 0 0 0
+1900 0 0 0 0 1
+1901 0 0 0 0 0
+1905 0 0 0 0 0
+1906 0 0 0 0 0
+1910 0 1 0 0 0
+1914 0 0 0 0 1
+1916 0 0 0 0 0
+1920 0 0 0 0 1
+1922 0 0 0 0 1
+1925 0 0 0 0 0
+1929 0 1 0 0 0
+1930 0 0 0 0 1
+1931 0 1 0 0 0
+1933 0 0 0 0 0
+1934 0 0 0 0 0
+1935 0 0 0 0 1
+1936 0 1 0 0 0
+1937 0 0 0 0 0
+1938 0 0 0 0 1
+1939 0 0 0 0 0
+1941 0 0 0 0 0
+1942 1 2 0 1 0
+1943 0 3 0 0 2
+1944 0 1 0 0 0
+1945 1 0 0 2 1
+1946 1 0 0 0 1
+1947 0 6 1 0 3
+1948 2 1 0 0 0
+1949 1 4 1 0 0
+1950 2 7 1 0 2
+1951 2 2 0 0 0
+1952 2 8 3 0 4
+1953 4 4 0 0 1
+1954 4 12 0 0 1
+1955 3 3 2 0 3
+1956 1 8 1 1 1
+1957 1 12 2 1 7
+1958 3 7 0 1 0
+1959 1 7 2 0 2
+1960 5 10 3 0 2
+1961 1 7 0 2 0
+1962 3 8 0 0 2
+1963 0 11 3 1 2
+1964 2 15 0 0 2
+1965 5 21 3 1 5
+1966 10 28 5 1 9
+1967 5 40 1 0 2
+1968 5 33 4 0 1
+1969 7 23 1 0 4
+1970 7 26 3 0 6
+1971 6 18 2 0 0
+1972 12 28 5 1 2
+1973 6 34 7 0 6
+1974 10 41 9 0 4
+1975 10 52 6 2 9
+1976 13 49 3 3 6
+1977 13 44 3 0 9
+1978 11 59 3 1 8
+1979 11 58 0 1 3
+1980 7 34 4 0 6
+1981 7 28 2 0 5
+1982 1 34 3 1 11
+1983 10 24 0 1 4
+1984 9 44 3 1 14
+1985 7 32 7 0 11
+1986 9 32 5 0 10
+1987 11 36 5 0 7
+1988 8 37 0 0 6
+1989 19 39 3 1 4
+1990 11 46 6 0 8
+1991 17 43 7 1 6
+1992 13 38 3 0 9
+1993 13 60 2 1 11
+1994 24 80 7 0 23
+1995 47 83 63 2 291
+1996 48 97 15 0 95
+1997 130 187 24 2 46
+1998 224 260 30 3 57
+1999 355 459 45 3 98
+2000 298 415 44 2 97
+2001 280 494 45 5 155
+2002 302 447 50 6 186
+2003 336 512 58 7 154
+2004 345 607 42 7 177
+2005 314 531 45 6 131
+2006 290 474 59 8 176
+2007 328 505 53 7 144
+2008 394 555 50 7 169
+2009 261 535 57 10 127
+2010 132 302 35 5 78
diff --git a/html/team2/duration_year_count/duration_plot.html b/html/team2/duration_year_count/duration_plot.html
new file mode 100644
index 0000000..b93d20e
--- /dev/null
+++ b/html/team2/duration_year_count/duration_plot.html
@@ -0,0 +1,106 @@
+
+
+UFO sightings : by Duration based on year
+This visualization shows the no.of UFO Sightings happened by duration of sighting mentioned in 'seconds' vs 'minutes' vs 'hours' etc.
+Please note the data covered is 23.9 percent of the whole data. Reason being the duration field is either empty or description is vague.
+
+} hostsConfigs - an array of Hosts, or configuration objects
+ * that will be used to create Host objects.
+ */
+
+
+Transport.prototype.setHosts = function (hostsConfigs) {
+ var globalConfig = this._config;
+ this.connectionPool.setHosts(_.map(hostsConfigs, function (conf) {
+ return conf instanceof Host ? conf : new Host(conf, globalConfig);
+ }));
+};
+/**
+ * Close the Transport, which closes the logs and connection pool
+ * @return {[type]} [description]
+ */
+
+
+Transport.prototype.close = function () {
+ this.log.close();
+ this.closed = true;
+
+ _.each(this._timers, clearTimeout);
+
+ this._timers = null;
+ this.connectionPool.close();
+};
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+
+/**
+ * Manager of connections to a node(s), capable of ensuring that connections are clear and living
+ * before providing them to the application
+ *
+ * @class ConnectionPool
+ * @constructor
+ * @param {Object} config - The config object passed to the transport.
+ */
+module.exports = ConnectionPool;
+
+var _ = __webpack_require__(0);
+
+var Log = __webpack_require__(5);
+
+function ConnectionPool(config) {
+ config = config || {};
+
+ _.makeBoundMethods(this);
+
+ if (!config.log) {
+ this.log = new Log();
+ config.log = this.log;
+ } else {
+ this.log = config.log;
+ } // we will need this when we create connections down the road
+
+
+ this._config = config; // get the selector config var
+
+ this.selector = _.funcEnum(config, 'selector', ConnectionPool.selectors, ConnectionPool.defaultSelector); // get the connection class
+
+ this.Connection = _.funcEnum(config, 'connectionClass', ConnectionPool.connectionClasses, ConnectionPool.defaultConnectionClass); // time that connections will wait before being revived
+
+ this.deadTimeout = config.hasOwnProperty('deadTimeout') ? config.deadTimeout : 60000;
+ this.maxDeadTimeout = config.hasOwnProperty('maxDeadTimeout') ? config.maxDeadTimeout : 18e5;
+ this.calcDeadTimeout = _.funcEnum(config, 'calcDeadTimeout', ConnectionPool.calcDeadTimeoutOptions, 'exponential'); // a map of connections to their "id" property, used when sniffing
+
+ this.index = {};
+ this._conns = {
+ alive: [],
+ dead: []
+ }; // information about timeouts for dead connections
+
+ this._timeouts = [];
+} // selector options
+
+
+ConnectionPool.selectors = __webpack_require__(19);
+ConnectionPool.defaultSelector = 'roundRobin'; // get the connection options
+
+ConnectionPool.connectionClasses = __webpack_require__(20);
+ConnectionPool.defaultConnectionClass = ConnectionPool.connectionClasses._default;
+delete ConnectionPool.connectionClasses._default; // the function that calculates timeouts based on attempts
+
+ConnectionPool.calcDeadTimeoutOptions = {
+ flat: function flat(attempt, baseTimeout) {
+ return baseTimeout;
+ },
+ exponential: function exponential(attempt, baseTimeout) {
+ return Math.min(baseTimeout * 2 * Math.pow(2, attempt * 0.5 - 1), this.maxDeadTimeout);
+ }
+};
+/**
+ * Selects a connection from the list using the this.selector
+ * Features:
+ * - detects if the selector is async or not
+ * - sync selectors should still return asynchronously
+ * - catches errors in sync selectors
+ * - automatically selects the first dead connection when there no living connections
+ *
+ * @param {Function} cb [description]
+ * @return {[type]} [description]
+ */
+
+ConnectionPool.prototype.select = function (cb) {
+ if (this._conns.alive.length) {
+ if (this.selector.length > 1) {
+ this.selector(this._conns.alive, cb);
+ } else {
+ try {
+ _.nextTick(cb, void 0, this.selector(this._conns.alive));
+ } catch (e) {
+ cb(e);
+ }
+ }
+ } else if (this._timeouts.length) {
+ this._selectDeadConnection(cb);
+ } else {
+ _.nextTick(cb, void 0);
+ }
+};
+/**
+ * Handler for the "set status" event emitted but the connections. It will move
+ * the connection to it's proper connection list (unless it was closed).
+ *
+ * @param {String} status - the connection's new status
+ * @param {String} oldStatus - the connection's old status
+ * @param {ConnectionAbstract} connection - the connection object itself
+ */
+
+
+ConnectionPool.prototype.onStatusSet = _.handler(function (status, oldStatus, connection) {
+ var index;
+ var died = status === 'dead';
+ var wasAlreadyDead = died && oldStatus === 'dead';
+ var revived = !died && oldStatus === 'dead';
+ var noChange = oldStatus === status;
+ var from = this._conns[oldStatus];
+ var to = this._conns[status];
+
+ if (noChange && !died) {
+ return true;
+ }
+
+ if (from !== to) {
+ if (_.isArray(from)) {
+ index = from.indexOf(connection);
+
+ if (index !== -1) {
+ from.splice(index, 1);
+ }
+ }
+
+ if (_.isArray(to)) {
+ index = to.indexOf(connection);
+
+ if (index === -1) {
+ to.push(connection);
+ }
+ }
+ }
+
+ if (died) {
+ this._onConnectionDied(connection, wasAlreadyDead);
+ }
+
+ if (revived) {
+ this._onConnectionRevived(connection);
+ }
+});
+/**
+ * Handler used to clear the times created when a connection dies
+ * @param {ConnectionAbstract} connection
+ */
+
+ConnectionPool.prototype._onConnectionRevived = function (connection) {
+ var timeout;
+
+ for (var i = 0; i < this._timeouts.length; i++) {
+ if (this._timeouts[i].conn === connection) {
+ timeout = this._timeouts[i];
+
+ if (timeout.id) {
+ clearTimeout(timeout.id);
+ }
+
+ this._timeouts.splice(i, 1);
+
+ break;
+ }
+ }
+};
+/**
+ * Handler used to update or create a timeout for the connection which has died
+ * @param {ConnectionAbstract} connection
+ * @param {Boolean} alreadyWasDead - If the connection was preivously dead this must be set to true
+ */
+
+
+ConnectionPool.prototype._onConnectionDied = function (connection, alreadyWasDead) {
+ var timeout;
+
+ if (alreadyWasDead) {
+ for (var i = 0; i < this._timeouts.length; i++) {
+ if (this._timeouts[i].conn === connection) {
+ timeout = this._timeouts[i];
+ break;
+ }
+ }
+ } else {
+ timeout = {
+ conn: connection,
+ attempt: 0,
+ revive: function revive(cb) {
+ timeout.attempt++;
+ connection.ping(function (err) {
+ connection.setStatus(err ? 'dead' : 'alive');
+
+ if (cb && typeof cb === 'function') {
+ cb(err);
+ }
+ });
+ }
+ };
+
+ this._timeouts.push(timeout);
+ }
+
+ if (timeout.id) {
+ clearTimeout(timeout.id);
+ }
+
+ var ms = this.calcDeadTimeout(timeout.attempt, this.deadTimeout);
+ timeout.id = setTimeout(timeout.revive, ms);
+ timeout.runAt = _.now() + ms;
+};
+
+ConnectionPool.prototype._selectDeadConnection = function (cb) {
+ var orderedTimeouts = _.sortBy(this._timeouts, 'runAt');
+
+ var log = this.log;
+ process.nextTick(function next() {
+ var timeout = orderedTimeouts.shift();
+
+ if (!timeout) {
+ cb(void 0);
+ return;
+ }
+
+ if (!timeout.conn) {
+ next();
+ return;
+ }
+
+ if (timeout.conn.status === 'dead') {
+ timeout.revive(function (err) {
+ if (err) {
+ log.warning('Unable to revive connection: ' + timeout.conn.id);
+ process.nextTick(next);
+ } else {
+ cb(void 0, timeout.conn);
+ }
+ });
+ } else {
+ cb(void 0, timeout.conn);
+ }
+ });
+};
+/**
+ * Returns a random list of nodes from the living connections up to the limit.
+ * If there are no living connections it will fall back to the dead connections.
+ * If there are no dead connections it will return nothing.
+ *
+ * This is used for testing (when we just want the one existing node)
+ * and sniffing, where using the selector to get all of the living connections
+ * is not reasonable.
+ *
+ * @param {string} [status] - optional status of the connection to fetch
+ * @param {Number} [limit] - optional limit on the number of connections to return
+ */
+
+
+ConnectionPool.prototype.getConnections = function (status, limit) {
+ var list;
+
+ if (status) {
+ list = this._conns[status];
+ } else {
+ list = this._conns[this._conns.alive.length ? 'alive' : 'dead'];
+ }
+
+ if (limit == null) {
+ return list.slice(0);
+ } else {
+ return _.shuffle(list).slice(0, limit);
+ }
+};
+/**
+ * Add a single connection to the pool and change it's status to "alive".
+ * The connection should inherit from ConnectionAbstract
+ *
+ * @param {ConnectionAbstract} connection - The connection to add
+ */
+
+
+ConnectionPool.prototype.addConnection = function (connection) {
+ if (!connection.id) {
+ connection.id = connection.host.toString();
+ }
+
+ if (!this.index[connection.id]) {
+ this.log.info('Adding connection to', connection.id);
+ this.index[connection.id] = connection;
+ connection.on('status set', this.bound.onStatusSet);
+ connection.setStatus('alive');
+ }
+};
+/**
+ * Remove a connection from the pool, and set it's status to "closed".
+ *
+ * @param {ConnectionAbstract} connection - The connection to remove/close
+ */
+
+
+ConnectionPool.prototype.removeConnection = function (connection) {
+ if (!connection.id) {
+ connection.id = connection.host.toString();
+ }
+
+ if (this.index[connection.id]) {
+ delete this.index[connection.id];
+ connection.setStatus('closed');
+ connection.removeListener('status set', this.bound.onStatusSet);
+ }
+};
+/**
+ * Override the internal node list. All connections that are not in the new host
+ * list are closed and removed. Non-unique hosts are ignored.
+ *
+ * @param {Host[]} hosts - An array of Host instances.
+ */
+
+
+ConnectionPool.prototype.setHosts = function (hosts) {
+ var connection;
+ var i;
+ var id;
+ var host;
+
+ var toRemove = _.clone(this.index);
+
+ for (i = 0; i < hosts.length; i++) {
+ host = hosts[i];
+ id = host.toString();
+
+ if (this.index[id]) {
+ delete toRemove[id];
+ } else {
+ connection = new this.Connection(host, this._config);
+ connection.id = id;
+ this.addConnection(connection);
+ }
+ }
+
+ var removeIds = _.keys(toRemove);
+
+ for (i = 0; i < removeIds.length; i++) {
+ this.removeConnection(this.index[removeIds[i]]);
+ }
+};
+
+ConnectionPool.prototype.getAllHosts = function () {
+ return _.values(this.index).map(function (connection) {
+ return connection.host;
+ });
+};
+/**
+ * Close the conncetion pool, as well as all of it's connections
+ */
+
+
+ConnectionPool.prototype.close = function () {
+ this.setHosts([]);
+};
+
+ConnectionPool.prototype.empty = ConnectionPool.prototype.close;
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**
+ * Connection that registers a module with angular, using angular's $http service
+ * to communicate with ES.
+ *
+ * @class connections.Angular
+ */
+module.exports = AngularConnector;
+
+var _ = __webpack_require__(0);
+
+var ConnectionAbstract = __webpack_require__(12);
+
+var ConnectionFault = __webpack_require__(4).ConnectionFault;
+
+function AngularConnector(host, config) {
+ ConnectionAbstract.call(this, host, config);
+ var self = this;
+ config.$injector.invoke(['$http', '$q', function ($http, $q) {
+ self.$q = $q;
+ self.$http = $http;
+ }]);
+}
+
+_.inherits(AngularConnector, ConnectionAbstract);
+
+AngularConnector.prototype.request = function (params, cb) {
+ var abort = this.$q.defer();
+ this.$http({
+ method: params.method,
+ url: this.host.makeUrl(params),
+ data: params.body,
+ cache: false,
+ headers: this.host.getHeaders(params.headers),
+ transformRequest: [],
+ transformResponse: [],
+ // not actually for timing out, that's handled by the transport
+ timeout: abort.promise
+ }).then(function (response) {
+ cb(null, response.data, response.status, response.headers());
+ }, function (err) {
+ if (err.status) {
+ cb(null, err.data, err.status, err.headers());
+ } else {
+ cb(new ConnectionFault(err.message));
+ }
+ });
+ return function () {
+ abort.resolve();
+ };
+};
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+/* eslint-disable no-proto */
+
+
+
+var base64 = __webpack_require__(27)
+var ieee754 = __webpack_require__(28)
+var isArray = __webpack_require__(29)
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ * incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+ ? global.TYPED_ARRAY_SUPPORT
+ : typedArraySupport()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+ return arr.foo() === 42 && // typed array instances can be augmented
+ typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+ arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+ } catch (e) {
+ return false
+ }
+}
+
+function kMaxLength () {
+ return Buffer.TYPED_ARRAY_SUPPORT
+ ? 0x7fffffff
+ : 0x3fffffff
+}
+
+function createBuffer (that, length) {
+ if (kMaxLength() < length) {
+ throw new RangeError('Invalid typed array length')
+ }
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = new Uint8Array(length)
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ if (that === null) {
+ that = new Buffer(length)
+ }
+ that.length = length
+ }
+
+ return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+ if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+ return new Buffer(arg, encodingOrOffset, length)
+ }
+
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new Error(
+ 'If encoding is specified then the first argument must be a string'
+ )
+ }
+ return allocUnsafe(this, arg)
+ }
+ return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+ arr.__proto__ = Buffer.prototype
+ return arr
+}
+
+function from (that, value, encodingOrOffset, length) {
+ if (typeof value === 'number') {
+ throw new TypeError('"value" argument must not be a number')
+ }
+
+ if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+ return fromArrayBuffer(that, value, encodingOrOffset, length)
+ }
+
+ if (typeof value === 'string') {
+ return fromString(that, value, encodingOrOffset)
+ }
+
+ return fromObject(that, value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(null, value, encodingOrOffset, length)
+}
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+ Buffer.prototype.__proto__ = Uint8Array.prototype
+ Buffer.__proto__ = Uint8Array
+ if (typeof Symbol !== 'undefined' && Symbol.species &&
+ Buffer[Symbol.species] === Buffer) {
+ // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true
+ })
+ }
+}
+
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be a number')
+ } else if (size < 0) {
+ throw new RangeError('"size" argument must not be negative')
+ }
+}
+
+function alloc (that, size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(that, size)
+ }
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(that, size).fill(fill, encoding)
+ : createBuffer(that, size).fill(fill)
+ }
+ return createBuffer(that, size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(null, size, fill, encoding)
+}
+
+function allocUnsafe (that, size) {
+ assertSize(size)
+ that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) {
+ for (var i = 0; i < size; ++i) {
+ that[i] = 0
+ }
+ }
+ return that
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(null, size)
+}
+
+function fromString (that, string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
+ }
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('"encoding" must be a valid string encoding')
+ }
+
+ var length = byteLength(string, encoding) | 0
+ that = createBuffer(that, length)
+
+ var actual = that.write(string, encoding)
+
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ that = that.slice(0, actual)
+ }
+
+ return that
+}
+
+function fromArrayLike (that, array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ that = createBuffer(that, length)
+ for (var i = 0; i < length; i += 1) {
+ that[i] = array[i] & 255
+ }
+ return that
+}
+
+function fromArrayBuffer (that, array, byteOffset, length) {
+ array.byteLength // this throws if `array` is not a valid ArrayBuffer
+
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('\'offset\' is out of bounds')
+ }
+
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('\'length\' is out of bounds')
+ }
+
+ if (byteOffset === undefined && length === undefined) {
+ array = new Uint8Array(array)
+ } else if (length === undefined) {
+ array = new Uint8Array(array, byteOffset)
+ } else {
+ array = new Uint8Array(array, byteOffset, length)
+ }
+
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = array
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ that = fromArrayLike(that, array)
+ }
+ return that
+}
+
+function fromObject (that, obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ that = createBuffer(that, len)
+
+ if (that.length === 0) {
+ return that
+ }
+
+ obj.copy(that, 0, 0, len)
+ return that
+ }
+
+ if (obj) {
+ if ((typeof ArrayBuffer !== 'undefined' &&
+ obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+ if (typeof obj.length !== 'number' || isnan(obj.length)) {
+ return createBuffer(that, 0)
+ }
+ return fromArrayLike(that, obj)
+ }
+
+ if (obj.type === 'Buffer' && isArray(obj.data)) {
+ return fromArrayLike(that, obj.data)
+ }
+ }
+
+ throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
+
+function checked (length) {
+ // Note: cannot use `length < kMaxLength()` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= kMaxLength()) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + kMaxLength().toString(16) + ' bytes')
+ }
+ return length | 0
+}
+
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
+ }
+ return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+ return !!(b != null && b._isBuffer)
+}
+
+Buffer.compare = function compare (a, b) {
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError('Arguments must be Buffers')
+ }
+
+ if (a === b) return 0
+
+ var x = a.length
+ var y = b.length
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.concat = function concat (list, length) {
+ if (!isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+
+ if (list.length === 0) {
+ return Buffer.alloc(0)
+ }
+
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
+ }
+ }
+
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
+ }
+ return buffer
+}
+
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
+ }
+ if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+ (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+ return string.byteLength
+ }
+ if (typeof string !== 'string') {
+ string = '' + string
+ }
+
+ var len = string.length
+ if (len === 0) return 0
+
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ case undefined:
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) return utf8ToBytes(string).length // assume utf8
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+ var loweredCase = false
+
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
+
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
+
+ if (end === undefined || end > this.length) {
+ end = this.length
+ }
+
+ if (end <= 0) {
+ return ''
+ }
+
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
+
+ if (end <= start) {
+ return ''
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
+
+ case 'ascii':
+ return asciiSlice(this, start, end)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
+
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
+ }
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
+ }
+ return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
+ }
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
+ }
+ return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
+
+Buffer.prototype.toString = function toString () {
+ var length = this.length | 0
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ if (this.length > 0) {
+ str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+ if (this.length > max) str += ' ... '
+ }
+ return ''
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError('Argument must be a Buffer')
+ }
+
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
+
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
+ }
+
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
+ }
+
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
+
+ if (this === target) return 0
+
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
+
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (isNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
+ }
+
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
+
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
+ }
+
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (Buffer.TYPED_ARRAY_SUPPORT &&
+ typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+ } else {
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+ }
+ }
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+ }
+
+ throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+ } else {
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
+ }
+ }
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
+ }
+
+ return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (isNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
+}
+
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset | 0
+ if (isFinite(length)) {
+ length = length | 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ // legacy write(string, encoding, offset, length) - remove in v0.13
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
+
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
+
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
+
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
+
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
+
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
+
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
+
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
+
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
+
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
+
+ return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
+
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
+
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
+}
+
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
+
+function hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+ }
+ return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
+
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
+
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
+
+ if (end < start) end = start
+
+ var newBuf
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ newBuf = this.subarray(start, end)
+ newBuf.__proto__ = Buffer.prototype
+ } else {
+ var sliceLen = end - start
+ newBuf = new Buffer(sliceLen, undefined)
+ for (var i = 0; i < sliceLen; ++i) {
+ newBuf[i] = this[i + start]
+ }
+ }
+
+ return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+ buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffffffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+ buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
+
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
+
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
+ }
+
+ var len = end - start
+ var i
+
+ if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+ // ascending copy from start
+ for (i = 0; i < len; ++i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, start + len),
+ targetStart
+ )
+ }
+
+ return len
+}
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if (code < 256) {
+ val = code
+ }
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
+ }
+
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
+ }
+
+ if (end <= start) {
+ return this
+ }
+
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
+
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
+ }
+ } else {
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : utf8ToBytes(new Buffer(val, encoding).toString())
+ var len = bytes.length
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
+ }
+
+ return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
+ }
+ return str
+}
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
+
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
+
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
+
+ // valid lead
+ leadSurrogate = codePoint
+
+ continue
+ }
+
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
+
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ }
+
+ leadSurrogate = null
+
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else {
+ throw new Error('Invalid code point')
+ }
+ }
+
+ return bytes
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
+
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function isnan (val) {
+ return val !== val // eslint-disable-line no-self-compare
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = ConnectionAbstract;
+
+var _ = __webpack_require__(0);
+
+var EventEmitter = __webpack_require__(13).EventEmitter;
+
+var Log = __webpack_require__(5);
+
+var Host = __webpack_require__(7);
+
+var errors = __webpack_require__(4);
+/**
+ * Abstract class used for Connection classes
+ * @class ConnectionAbstract
+ * @constructor
+ */
+
+
+function ConnectionAbstract(host, config) {
+ config = config || {};
+ EventEmitter.call(this);
+ this.log = config.log || new Log();
+ this.pingTimeout = config.pingTimeout || 3000;
+
+ if (!host) {
+ throw new TypeError('Missing host');
+ } else if (host instanceof Host) {
+ this.host = host;
+ } else {
+ throw new TypeError('Invalid host');
+ }
+
+ _.makeBoundMethods(this);
+}
+
+_.inherits(ConnectionAbstract, EventEmitter);
+/**
+ * Make a request using this connection. Must be overridden by Connection classes, which can add whatever keys to
+ * params that they like. These are just the basics.
+ *
+ * @param [params] {Object} - The parameters for the request
+ * @param params.path {String} - The path for which you are requesting
+ * @param params.method {String} - The HTTP method for the request (GET, HEAD, etc.)
+ * @param params.requestTimeout {Integer} - The amount of time in milliseconds that this request should be allowed to run for.
+ * @param cb {Function} - A callback to be called once with `cb(err, responseBody, responseStatus)`
+ */
+
+
+ConnectionAbstract.prototype.request = function () {
+ throw new Error('Connection#request must be overwritten by the Connector');
+};
+
+ConnectionAbstract.prototype.ping = function (params, cb) {
+ if (typeof params === 'function') {
+ cb = params;
+ params = null;
+ } else {
+ cb = typeof cb === 'function' ? cb : null;
+ }
+
+ var requestTimeout = this.pingTimeout;
+ var requestTimeoutId;
+ var aborted;
+ var abort;
+
+ if (params && params.hasOwnProperty('requestTimeout')) {
+ requestTimeout = params.requestTimeout;
+ }
+
+ abort = this.request(_.defaults(params || {}, {
+ path: '/',
+ method: 'HEAD'
+ }), function (err) {
+ if (aborted) {
+ return;
+ }
+
+ clearTimeout(requestTimeoutId);
+
+ if (cb) {
+ cb(err);
+ }
+ });
+
+ if (requestTimeout) {
+ requestTimeoutId = setTimeout(function () {
+ if (abort) {
+ abort();
+ }
+
+ aborted = true;
+
+ if (cb) {
+ cb(new errors.RequestTimeout('Ping Timeout after ' + requestTimeout + 'ms'));
+ }
+ }, requestTimeout);
+ }
+};
+
+ConnectionAbstract.prototype.setStatus = function (status) {
+ var origStatus = this.status;
+ this.status = status;
+ this.emit('status set', status, origStatus, this);
+
+ if (status === 'closed') {
+ this.removeAllListeners();
+ }
+};
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports) {
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ // At least give some kind of context to the user
+ var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+ err.context = er;
+ throw err;
+ }
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ args = Array.prototype.slice.call(arguments, 1);
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ args = Array.prototype.slice.call(arguments, 1);
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else if (listeners) {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.prototype.listenerCount = function(type) {
+ if (this._events) {
+ var evlistener = this._events[type];
+
+ if (isFunction(evlistener))
+ return 1;
+ else if (evlistener)
+ return evlistener.length;
+ }
+ return 0;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ return emitter.listenerCount(type);
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+var punycode = __webpack_require__(37);
+var util = __webpack_require__(38);
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+ this.protocol = null;
+ this.slashes = null;
+ this.auth = null;
+ this.host = null;
+ this.port = null;
+ this.hostname = null;
+ this.hash = null;
+ this.search = null;
+ this.query = null;
+ this.pathname = null;
+ this.path = null;
+ this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+ portPattern = /:[0-9]*$/,
+
+ // Special case for a simple path URL
+ simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+ // RFC 2396: characters reserved for delimiting URLs.
+ // We actually just auto-escape these.
+ delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+ // RFC 2396: characters not allowed for various reasons.
+ unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+ // Allowed by RFCs, but cause of XSS attacks. Always escape these.
+ autoEscape = ['\''].concat(unwise),
+ // Characters that are never ever allowed in a hostname.
+ // Note that any invalid chars are also handled, but these
+ // are the ones that are *expected* to be seen, so we fast-path
+ // them.
+ nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+ hostEndingChars = ['/', '?', '#'],
+ hostnameMaxLen = 255,
+ hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+ hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+ // protocols that can allow "unsafe" and "unwise" chars.
+ unsafeProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that never have a hostname.
+ hostlessProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that always contain a // bit.
+ slashedProtocol = {
+ 'http': true,
+ 'https': true,
+ 'ftp': true,
+ 'gopher': true,
+ 'file': true,
+ 'http:': true,
+ 'https:': true,
+ 'ftp:': true,
+ 'gopher:': true,
+ 'file:': true
+ },
+ querystring = __webpack_require__(15);
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+ if (url && util.isObject(url) && url instanceof Url) return url;
+
+ var u = new Url;
+ u.parse(url, parseQueryString, slashesDenoteHost);
+ return u;
+}
+
+Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+ if (!util.isString(url)) {
+ throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+ }
+
+ // Copy chrome, IE, opera backslash-handling behavior.
+ // Back slashes before the query string get converted to forward slashes
+ // See: https://code.google.com/p/chromium/issues/detail?id=25916
+ var queryIndex = url.indexOf('?'),
+ splitter =
+ (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+ uSplit = url.split(splitter),
+ slashRegex = /\\/g;
+ uSplit[0] = uSplit[0].replace(slashRegex, '/');
+ url = uSplit.join(splitter);
+
+ var rest = url;
+
+ // trim before proceeding.
+ // This is to support parse stuff like " http://foo.com \n"
+ rest = rest.trim();
+
+ if (!slashesDenoteHost && url.split('#').length === 1) {
+ // Try fast path regexp
+ var simplePath = simplePathPattern.exec(rest);
+ if (simplePath) {
+ this.path = rest;
+ this.href = rest;
+ this.pathname = simplePath[1];
+ if (simplePath[2]) {
+ this.search = simplePath[2];
+ if (parseQueryString) {
+ this.query = querystring.parse(this.search.substr(1));
+ } else {
+ this.query = this.search.substr(1);
+ }
+ } else if (parseQueryString) {
+ this.search = '';
+ this.query = {};
+ }
+ return this;
+ }
+ }
+
+ var proto = protocolPattern.exec(rest);
+ if (proto) {
+ proto = proto[0];
+ var lowerProto = proto.toLowerCase();
+ this.protocol = lowerProto;
+ rest = rest.substr(proto.length);
+ }
+
+ // figure out if it's got a host
+ // user@server is *always* interpreted as a hostname, and url
+ // resolution will treat //foo/bar as host=foo,path=bar because that's
+ // how the browser resolves relative URLs.
+ if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+ var slashes = rest.substr(0, 2) === '//';
+ if (slashes && !(proto && hostlessProtocol[proto])) {
+ rest = rest.substr(2);
+ this.slashes = true;
+ }
+ }
+
+ if (!hostlessProtocol[proto] &&
+ (slashes || (proto && !slashedProtocol[proto]))) {
+
+ // there's a hostname.
+ // the first instance of /, ?, ;, or # ends the host.
+ //
+ // If there is an @ in the hostname, then non-host chars *are* allowed
+ // to the left of the last @ sign, unless some host-ending character
+ // comes *before* the @-sign.
+ // URLs are obnoxious.
+ //
+ // ex:
+ // http://a@b@c/ => user:a@b host:c
+ // http://a@b?@c => user:a host:c path:/?@c
+
+ // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+ // Review our test case against browsers more comprehensively.
+
+ // find the first instance of any hostEndingChars
+ var hostEnd = -1;
+ for (var i = 0; i < hostEndingChars.length; i++) {
+ var hec = rest.indexOf(hostEndingChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+
+ // at this point, either we have an explicit point where the
+ // auth portion cannot go past, or the last @ char is the decider.
+ var auth, atSign;
+ if (hostEnd === -1) {
+ // atSign can be anywhere.
+ atSign = rest.lastIndexOf('@');
+ } else {
+ // atSign must be in auth portion.
+ // http://a@b/c@d => host:b auth:a path:/c@d
+ atSign = rest.lastIndexOf('@', hostEnd);
+ }
+
+ // Now we have a portion which is definitely the auth.
+ // Pull that off.
+ if (atSign !== -1) {
+ auth = rest.slice(0, atSign);
+ rest = rest.slice(atSign + 1);
+ this.auth = decodeURIComponent(auth);
+ }
+
+ // the host is the remaining to the left of the first non-host char
+ hostEnd = -1;
+ for (var i = 0; i < nonHostChars.length; i++) {
+ var hec = rest.indexOf(nonHostChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+ // if we still have not hit it, then the entire thing is a host.
+ if (hostEnd === -1)
+ hostEnd = rest.length;
+
+ this.host = rest.slice(0, hostEnd);
+ rest = rest.slice(hostEnd);
+
+ // pull out port.
+ this.parseHost();
+
+ // we've indicated that there is a hostname,
+ // so even if it's empty, it has to be present.
+ this.hostname = this.hostname || '';
+
+ // if hostname begins with [ and ends with ]
+ // assume that it's an IPv6 address.
+ var ipv6Hostname = this.hostname[0] === '[' &&
+ this.hostname[this.hostname.length - 1] === ']';
+
+ // validate a little.
+ if (!ipv6Hostname) {
+ var hostparts = this.hostname.split(/\./);
+ for (var i = 0, l = hostparts.length; i < l; i++) {
+ var part = hostparts[i];
+ if (!part) continue;
+ if (!part.match(hostnamePartPattern)) {
+ var newpart = '';
+ for (var j = 0, k = part.length; j < k; j++) {
+ if (part.charCodeAt(j) > 127) {
+ // we replace non-ASCII char with a temporary placeholder
+ // we need this to make sure size of hostname is not
+ // broken by replacing non-ASCII by nothing
+ newpart += 'x';
+ } else {
+ newpart += part[j];
+ }
+ }
+ // we test again with ASCII char only
+ if (!newpart.match(hostnamePartPattern)) {
+ var validParts = hostparts.slice(0, i);
+ var notHost = hostparts.slice(i + 1);
+ var bit = part.match(hostnamePartStart);
+ if (bit) {
+ validParts.push(bit[1]);
+ notHost.unshift(bit[2]);
+ }
+ if (notHost.length) {
+ rest = '/' + notHost.join('.') + rest;
+ }
+ this.hostname = validParts.join('.');
+ break;
+ }
+ }
+ }
+ }
+
+ if (this.hostname.length > hostnameMaxLen) {
+ this.hostname = '';
+ } else {
+ // hostnames are always lower case.
+ this.hostname = this.hostname.toLowerCase();
+ }
+
+ if (!ipv6Hostname) {
+ // IDNA Support: Returns a punycoded representation of "domain".
+ // It only converts parts of the domain name that
+ // have non-ASCII characters, i.e. it doesn't matter if
+ // you call it with a domain that already is ASCII-only.
+ this.hostname = punycode.toASCII(this.hostname);
+ }
+
+ var p = this.port ? ':' + this.port : '';
+ var h = this.hostname || '';
+ this.host = h + p;
+ this.href += this.host;
+
+ // strip [ and ] from the hostname
+ // the host field still retains them, though
+ if (ipv6Hostname) {
+ this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+ if (rest[0] !== '/') {
+ rest = '/' + rest;
+ }
+ }
+ }
+
+ // now rest is set to the post-host stuff.
+ // chop off any delim chars.
+ if (!unsafeProtocol[lowerProto]) {
+
+ // First, make 100% sure that any "autoEscape" chars get
+ // escaped, even if encodeURIComponent doesn't think they
+ // need to be.
+ for (var i = 0, l = autoEscape.length; i < l; i++) {
+ var ae = autoEscape[i];
+ if (rest.indexOf(ae) === -1)
+ continue;
+ var esc = encodeURIComponent(ae);
+ if (esc === ae) {
+ esc = escape(ae);
+ }
+ rest = rest.split(ae).join(esc);
+ }
+ }
+
+
+ // chop off from the tail first.
+ var hash = rest.indexOf('#');
+ if (hash !== -1) {
+ // got a fragment string.
+ this.hash = rest.substr(hash);
+ rest = rest.slice(0, hash);
+ }
+ var qm = rest.indexOf('?');
+ if (qm !== -1) {
+ this.search = rest.substr(qm);
+ this.query = rest.substr(qm + 1);
+ if (parseQueryString) {
+ this.query = querystring.parse(this.query);
+ }
+ rest = rest.slice(0, qm);
+ } else if (parseQueryString) {
+ // no query string, but parseQueryString still requested
+ this.search = '';
+ this.query = {};
+ }
+ if (rest) this.pathname = rest;
+ if (slashedProtocol[lowerProto] &&
+ this.hostname && !this.pathname) {
+ this.pathname = '/';
+ }
+
+ //to support http.request
+ if (this.pathname || this.search) {
+ var p = this.pathname || '';
+ var s = this.search || '';
+ this.path = p + s;
+ }
+
+ // finally, reconstruct the href based on what has been validated.
+ this.href = this.format();
+ return this;
+};
+
+// format a parsed object into a url string
+function urlFormat(obj) {
+ // ensure it's an object, and not a string url.
+ // If it's an obj, this is a no-op.
+ // this way, you can call url_format() on strings
+ // to clean up potentially wonky urls.
+ if (util.isString(obj)) obj = urlParse(obj);
+ if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+ return obj.format();
+}
+
+Url.prototype.format = function() {
+ var auth = this.auth || '';
+ if (auth) {
+ auth = encodeURIComponent(auth);
+ auth = auth.replace(/%3A/i, ':');
+ auth += '@';
+ }
+
+ var protocol = this.protocol || '',
+ pathname = this.pathname || '',
+ hash = this.hash || '',
+ host = false,
+ query = '';
+
+ if (this.host) {
+ host = auth + this.host;
+ } else if (this.hostname) {
+ host = auth + (this.hostname.indexOf(':') === -1 ?
+ this.hostname :
+ '[' + this.hostname + ']');
+ if (this.port) {
+ host += ':' + this.port;
+ }
+ }
+
+ if (this.query &&
+ util.isObject(this.query) &&
+ Object.keys(this.query).length) {
+ query = querystring.stringify(this.query);
+ }
+
+ var search = this.search || (query && ('?' + query)) || '';
+
+ if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+ // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
+ // unless they had them to begin with.
+ if (this.slashes ||
+ (!protocol || slashedProtocol[protocol]) && host !== false) {
+ host = '//' + (host || '');
+ if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+ } else if (!host) {
+ host = '';
+ }
+
+ if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+ if (search && search.charAt(0) !== '?') search = '?' + search;
+
+ pathname = pathname.replace(/[?#]/g, function(match) {
+ return encodeURIComponent(match);
+ });
+ search = search.replace('#', '%23');
+
+ return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+ return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function(relative) {
+ return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+ if (!source) return relative;
+ return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function(relative) {
+ if (util.isString(relative)) {
+ var rel = new Url();
+ rel.parse(relative, false, true);
+ relative = rel;
+ }
+
+ var result = new Url();
+ var tkeys = Object.keys(this);
+ for (var tk = 0; tk < tkeys.length; tk++) {
+ var tkey = tkeys[tk];
+ result[tkey] = this[tkey];
+ }
+
+ // hash is always overridden, no matter what.
+ // even href="" will remove it.
+ result.hash = relative.hash;
+
+ // if the relative url is empty, then there's nothing left to do here.
+ if (relative.href === '') {
+ result.href = result.format();
+ return result;
+ }
+
+ // hrefs like //foo/bar always cut to the protocol.
+ if (relative.slashes && !relative.protocol) {
+ // take everything except the protocol from relative
+ var rkeys = Object.keys(relative);
+ for (var rk = 0; rk < rkeys.length; rk++) {
+ var rkey = rkeys[rk];
+ if (rkey !== 'protocol')
+ result[rkey] = relative[rkey];
+ }
+
+ //urlParse appends trailing / to urls like http://www.example.com
+ if (slashedProtocol[result.protocol] &&
+ result.hostname && !result.pathname) {
+ result.path = result.pathname = '/';
+ }
+
+ result.href = result.format();
+ return result;
+ }
+
+ if (relative.protocol && relative.protocol !== result.protocol) {
+ // if it's a known url protocol, then changing
+ // the protocol does weird things
+ // first, if it's not file:, then we MUST have a host,
+ // and if there was a path
+ // to begin with, then we MUST have a path.
+ // if it is file:, then the host is dropped,
+ // because that's known to be hostless.
+ // anything else is assumed to be absolute.
+ if (!slashedProtocol[relative.protocol]) {
+ var keys = Object.keys(relative);
+ for (var v = 0; v < keys.length; v++) {
+ var k = keys[v];
+ result[k] = relative[k];
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ result.protocol = relative.protocol;
+ if (!relative.host && !hostlessProtocol[relative.protocol]) {
+ var relPath = (relative.pathname || '').split('/');
+ while (relPath.length && !(relative.host = relPath.shift()));
+ if (!relative.host) relative.host = '';
+ if (!relative.hostname) relative.hostname = '';
+ if (relPath[0] !== '') relPath.unshift('');
+ if (relPath.length < 2) relPath.unshift('');
+ result.pathname = relPath.join('/');
+ } else {
+ result.pathname = relative.pathname;
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ result.host = relative.host || '';
+ result.auth = relative.auth;
+ result.hostname = relative.hostname || relative.host;
+ result.port = relative.port;
+ // to support http.request
+ if (result.pathname || result.search) {
+ var p = result.pathname || '';
+ var s = result.search || '';
+ result.path = p + s;
+ }
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+ }
+
+ var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+ isRelAbs = (
+ relative.host ||
+ relative.pathname && relative.pathname.charAt(0) === '/'
+ ),
+ mustEndAbs = (isRelAbs || isSourceAbs ||
+ (result.host && relative.pathname)),
+ removeAllDots = mustEndAbs,
+ srcPath = result.pathname && result.pathname.split('/') || [],
+ relPath = relative.pathname && relative.pathname.split('/') || [],
+ psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+ // if the url is a non-slashed url, then relative
+ // links like ../.. should be able
+ // to crawl up to the hostname, as well. This is strange.
+ // result.protocol has already been set by now.
+ // Later on, put the first path part into the host field.
+ if (psychotic) {
+ result.hostname = '';
+ result.port = null;
+ if (result.host) {
+ if (srcPath[0] === '') srcPath[0] = result.host;
+ else srcPath.unshift(result.host);
+ }
+ result.host = '';
+ if (relative.protocol) {
+ relative.hostname = null;
+ relative.port = null;
+ if (relative.host) {
+ if (relPath[0] === '') relPath[0] = relative.host;
+ else relPath.unshift(relative.host);
+ }
+ relative.host = null;
+ }
+ mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+ }
+
+ if (isRelAbs) {
+ // it's absolute.
+ result.host = (relative.host || relative.host === '') ?
+ relative.host : result.host;
+ result.hostname = (relative.hostname || relative.hostname === '') ?
+ relative.hostname : result.hostname;
+ result.search = relative.search;
+ result.query = relative.query;
+ srcPath = relPath;
+ // fall through to the dot-handling below.
+ } else if (relPath.length) {
+ // it's relative
+ // throw away the existing file, and take the new path instead.
+ if (!srcPath) srcPath = [];
+ srcPath.pop();
+ srcPath = srcPath.concat(relPath);
+ result.search = relative.search;
+ result.query = relative.query;
+ } else if (!util.isNullOrUndefined(relative.search)) {
+ // just pull out the search.
+ // like href='?foo'.
+ // Put this after the other two cases because it simplifies the booleans
+ if (psychotic) {
+ result.hostname = result.host = srcPath.shift();
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ //to support http.request
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ if (!srcPath.length) {
+ // no path at all. easy.
+ // we've already handled the other stuff above.
+ result.pathname = null;
+ //to support http.request
+ if (result.search) {
+ result.path = '/' + result.search;
+ } else {
+ result.path = null;
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ // if a url ENDs in . or .., then it must get a trailing slash.
+ // however, if it ends in anything else non-slashy,
+ // then it must NOT get a trailing slash.
+ var last = srcPath.slice(-1)[0];
+ var hasTrailingSlash = (
+ (result.host || relative.host || srcPath.length > 1) &&
+ (last === '.' || last === '..') || last === '');
+
+ // strip single dots, resolve double dots to parent dir
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = srcPath.length; i >= 0; i--) {
+ last = srcPath[i];
+ if (last === '.') {
+ srcPath.splice(i, 1);
+ } else if (last === '..') {
+ srcPath.splice(i, 1);
+ up++;
+ } else if (up) {
+ srcPath.splice(i, 1);
+ up--;
+ }
+ }
+
+ // if the path is allowed to go above the root, restore leading ..s
+ if (!mustEndAbs && !removeAllDots) {
+ for (; up--; up) {
+ srcPath.unshift('..');
+ }
+ }
+
+ if (mustEndAbs && srcPath[0] !== '' &&
+ (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+ srcPath.unshift('');
+ }
+
+ if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+ srcPath.push('');
+ }
+
+ var isAbsolute = srcPath[0] === '' ||
+ (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+ // put the host back
+ if (psychotic) {
+ result.hostname = result.host = isAbsolute ? '' :
+ srcPath.length ? srcPath.shift() : '';
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+
+ mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+ if (mustEndAbs && !isAbsolute) {
+ srcPath.unshift('');
+ }
+
+ if (!srcPath.length) {
+ result.pathname = null;
+ result.path = null;
+ } else {
+ result.pathname = srcPath.join('/');
+ }
+
+ //to support request.http
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.auth = relative.auth || result.auth;
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+};
+
+Url.prototype.parseHost = function() {
+ var host = this.host;
+ var port = portPattern.exec(host);
+ if (port) {
+ port = port[0];
+ if (port !== ':') {
+ this.port = port.substr(1);
+ }
+ host = host.substr(0, host.length - port.length);
+ }
+ if (host) this.hostname = host;
+};
+
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.decode = exports.parse = __webpack_require__(39);
+exports.encode = exports.stringify = __webpack_require__(40);
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = {
+ console: __webpack_require__(41)
+};
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _ = __webpack_require__(0);
+/**
+ * Abstract class providing common functionality to loggers
+ * @param {[type]} log [description]
+ * @param {[type]} config [description]
+ */
+
+
+function LoggerAbstract(log, config) {
+ this.log = log;
+ this.listeningLevels = [];
+
+ _.makeBoundMethods(this); // when the log closes, remove our event listeners
+
+
+ this.log.once('closing', this.bound.cleanUpListeners);
+ this.setupListeners(config.levels);
+}
+
+function padNumToTen(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+/**
+ * Create a timestamp string used in the format function. Defers to Log.timestamp if it is defined,
+ * Also, feel free to override this at the logger level.
+ * @return {String} - Timestamp in ISO 8601 UTC
+ */
+
+
+LoggerAbstract.prototype.timestamp = function () {
+ var d = new Date();
+ return d.getUTCFullYear() + '-' + padNumToTen(d.getUTCMonth() + 1) + '-' + padNumToTen(d.getUTCDate()) + 'T' + padNumToTen(d.getUTCHours()) + ':' + padNumToTen(d.getUTCMinutes()) + ':' + padNumToTen(d.getUTCSeconds()) + 'Z';
+};
+
+function indent(text, spaces) {
+ var space = _.repeat(' ', spaces || 2);
+
+ return (text || '').split(/\r?\n/).map(function (line) {
+ return space + line;
+ }).join('\n');
+}
+
+LoggerAbstract.prototype.format = function (label, message) {
+ return label + ': ' + this.timestamp() + '\n' + indent(message) + '\n\n';
+};
+
+LoggerAbstract.prototype.write = function () {
+ throw new Error('This should be overwritten by the logger');
+};
+/**
+ * Clear the current event listeners and then re-listen for events based on the level specified
+ *
+ * @method setupListeners
+ * @private
+ * @param {Integer} level - The max log level that this logger should listen to
+ * @return {undefined}
+ */
+
+
+LoggerAbstract.prototype.setupListeners = function (levels) {
+ this.cleanUpListeners();
+ this.listeningLevels = [];
+
+ _.each(levels, _.bind(function (level) {
+ var fnName = 'on' + _.ucfirst(level);
+
+ if (this.bound[fnName]) {
+ this.listeningLevels.push(level);
+ this.log.on(level, this.bound[fnName]);
+ } else {
+ throw new Error('Unable to listen for level "' + level + '"');
+ }
+ }, this));
+};
+/**
+ * Clear the current event listeners
+ *
+ * @method cleanUpListeners
+ * @private
+ * @return {undefined}
+ */
+
+
+LoggerAbstract.prototype.cleanUpListeners = _.handler(function () {
+ _.each(this.listeningLevels, _.bind(function (level) {
+ this.log.removeListener(level, this.bound['on' + _.ucfirst(level)]);
+ }, this));
+});
+/**
+ * Handler for the logs "error" event
+ *
+ * @method onError
+ * @private
+ * @param {Error} e - The Error object to log
+ * @return {undefined}
+ */
+
+LoggerAbstract.prototype.onError = _.handler(function (e) {
+ this.write(e.name === 'Error' ? 'ERROR' : e.name, e.stack);
+});
+/**
+ * Handler for the logs "warning" event
+ *
+ * @method onWarning
+ * @private
+ * @param {String} msg - The message to be logged
+ * @return {undefined}
+ */
+
+LoggerAbstract.prototype.onWarning = _.handler(function (msg) {
+ this.write('WARNING', msg);
+});
+/**
+ * Handler for the logs "info" event
+ *
+ * @method onInfo
+ * @private
+ * @param {String} msg - The message to be logged
+ * @return {undefined}
+ */
+
+LoggerAbstract.prototype.onInfo = _.handler(function (msg) {
+ this.write('INFO', msg);
+});
+/**
+ * Handler for the logs "debug" event
+ *
+ * @method onDebug
+ * @private
+ * @param {String} msg - The message to be logged
+ * @return {undefined}
+ */
+
+LoggerAbstract.prototype.onDebug = _.handler(function (msg) {
+ this.write('DEBUG', msg);
+});
+/**
+ * Handler for the logs "trace" event
+ *
+ * @method onTrace
+ * @private
+ * @param {String} msg - The message to be logged
+ * @return {undefined}
+ */
+
+LoggerAbstract.prototype.onTrace = _.handler(function (requestDetails) {
+ this.write('TRACE', this._formatTraceMessage(requestDetails));
+});
+
+LoggerAbstract.prototype._formatTraceMessage = function (req) {
+ return '-> ' + req.method + ' ' + req.url + '\n' + this._prettyJson(req.body) + '\n' + '<- ' + req.status + '\n' + this._prettyJson(req.response);
+ /*
+ -> GET https://sldfkjsdlfksjdf:9200/slsdkfjlxckvxhclks?sdlkj=sdlfkje
+ {
+ asdflksjdf
+ }
+
+ <- 502
+ {
+ sldfksjdlf
+ }
+ */
+};
+
+LoggerAbstract.prototype._prettyJson = function (body) {
+ try {
+ if (typeof body === 'string') {
+ body = JSON.parse(body);
+ }
+
+ return JSON.stringify(body, null, ' ').replace(/'/g, "\\u0027");
+ } catch (e) {
+ return typeof body === 'string' ? body : '';
+ }
+};
+
+module.exports = LoggerAbstract;
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**
+ * A client that makes requests to Elasticsearch via a {{#crossLink "Transport"}}Transport{{/crossLink}}
+ *
+ * Initializing a client might look something like:
+ *
+ * ```
+ * var client = new es.Client({
+ * hosts: [
+ * 'es1.net:9200',
+ * {
+ * host: 'es2.net',
+ * port: 9200
+ * }
+ * ],
+ * sniffOnStart: true,
+ * log: {
+ * type: 'file',
+ * level: 'warning'
+ * }
+ * });
+ * ```
+ *
+ * @class Client
+ * @constructor
+ */
+module.exports = Client;
+
+var Transport = __webpack_require__(8);
+
+var clientAction = __webpack_require__(1);
+
+var _ = __webpack_require__(0);
+
+function Client(config) {
+ config = config || {};
+
+ if (config.__reused) {
+ throw new Error('Do not reuse objects to configure the elasticsearch Client class: ' + 'https://github.com/elasticsearch/elasticsearch-js/issues/33');
+ } else {
+ config.__reused = true;
+ }
+
+ function EsApiClient() {
+ // our client will log minimally by default
+ if (!config.hasOwnProperty('log')) {
+ config.log = 'warning';
+ }
+
+ if (!config.hosts && !config.host) {
+ config.host = 'http://localhost:9200';
+ }
+
+ this.close = function () {
+ this.transport.close();
+ };
+
+ this.transport = new Transport(config);
+
+ _.each(EsApiClient.prototype, _.bind(function (Fn, prop) {
+ if (Fn.prototype instanceof clientAction.ApiNamespace) {
+ this[prop] = new Fn(this.transport, this);
+ }
+ }, this));
+
+ delete this._namespaces;
+ }
+
+ EsApiClient.prototype = _.funcEnum(config, 'apiVersion', Client.apis, '_default');
+
+ if (!config.sniffEndpoint && EsApiClient.prototype === Client.apis['0.90']) {
+ config.sniffEndpoint = '/_cluster/nodes';
+ }
+
+ var Constructor = EsApiClient;
+
+ if (config.plugins) {
+ Constructor.prototype = _.cloneDeep(Constructor.prototype);
+
+ _.each(config.plugins, function (setup) {
+ Constructor = setup(Constructor, config, {
+ apis: __webpack_require__(24),
+ connectors: __webpack_require__(20),
+ loggers: __webpack_require__(16),
+ selectors: __webpack_require__(19),
+ serializers: __webpack_require__(21),
+ Client: __webpack_require__(18),
+ clientAction: clientAction,
+ Connection: __webpack_require__(12),
+ ConnectionPool: __webpack_require__(9),
+ Errors: __webpack_require__(4),
+ Host: __webpack_require__(7),
+ Log: __webpack_require__(5),
+ Logger: __webpack_require__(17),
+ NodesToHost: __webpack_require__(23),
+ Transport: __webpack_require__(8),
+ utils: __webpack_require__(0)
+ }) || Constructor;
+ });
+ }
+
+ return new Constructor();
+}
+
+Client.apis = __webpack_require__(24);
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = {
+ random: __webpack_require__(45),
+ roundRobin: __webpack_require__(46)
+};
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var opts = {
+ xhr: __webpack_require__(47),
+ jquery: __webpack_require__(48),
+ angular: __webpack_require__(10)
+};
+
+var _ = __webpack_require__(0); // remove modules that have been ignored by browserify
+
+
+_.each(opts, function (conn, name) {
+ if (typeof conn !== 'function') {
+ delete opts[name];
+ }
+}); // custom _default specification
+
+
+if (opts.xhr) {
+ opts._default = 'xhr';
+} else if (opts.angular) {
+ opts._default = 'angular';
+} else {
+ opts._default = 'jquery';
+}
+
+module.exports = opts;
+
+/***/ }),
+/* 21 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = {
+ angular: __webpack_require__(49),
+ json: __webpack_require__(22)
+};
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/**
+ * Simple JSON serializer
+ * @type {[type]}
+ */
+module.exports = Json;
+
+var _ = __webpack_require__(0);
+
+function Json() {}
+/**
+ * Converts a value into a string, or an error
+ * @param {*} val - Any value, methods are stripped and
+ * see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify about other params
+ * @return {String|Error} - A string is always returned, unless an error occured. then it will be that error.
+ */
+
+
+Json.prototype.serialize = function (val, replacer, spaces) {
+ switch (_typeof(val)) {
+ case 'string':
+ return val;
+
+ case 'object':
+ if (val) {
+ return JSON.stringify(val, replacer, spaces);
+ }
+
+ /* falls through */
+
+ default:
+ return;
+ }
+};
+
+Json.prototype.serialize.contentType = 'application/json';
+/**
+ * Parse a JSON string, if it is already parsed it is ignored
+ * @param {String} str - the string to parse
+ * @return {[type]}
+ */
+
+Json.prototype.deserialize = function (str) {
+ if (typeof str === 'string') {
+ try {
+ return JSON.parse(str);
+ } catch (e) {}
+ }
+};
+
+Json.prototype.bulkBody = function (val) {
+ var body = '',
+ i;
+
+ if (_.isArray(val)) {
+ for (i = 0; i < val.length; i++) {
+ body += this.serialize(val[i]) + '\n';
+ }
+ } else if (typeof val === 'string') {
+ // make sure the string ends in a new line
+ body = val + (val[val.length - 1] === '\n' ? '' : '\n');
+ } else {
+ throw new TypeError('Bulk body should either be an Array of commands/string, or a String');
+ }
+
+ return body;
+};
+
+Json.prototype.bulkBody.contentType = 'application/x-ndjson';
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _ = __webpack_require__(0);
+
+var extractHostPartsRE1x = /\[(?:(.*)\/)?(.+?):(\d+)\]/;
+
+function makeNodeParser(hostProp) {
+ return function (nodes) {
+ return _.transform(nodes, function (hosts, node, id) {
+ var address = _.get(node, hostProp);
+
+ if (!address) return;
+ var host = {
+ host: undefined,
+ port: undefined,
+ _meta: {
+ id: id,
+ name: node.name,
+ version: node.version
+ }
+ };
+ var malformedError = new Error('Malformed ' + hostProp + '.' + ' Got ' + JSON.stringify(address) + ' and expected it to match "{hostname?}/{ip}:{port}".');
+ var matches1x = extractHostPartsRE1x.exec(address);
+
+ if (matches1x) {
+ host.host = matches1x[1] || matches1x[2];
+ host.port = parseInt(matches1x[3], 10);
+ hosts.push(host);
+ return;
+ }
+
+ if (address.indexOf('/') > -1) {
+ var withHostParts = address.split('/');
+ if (withHostParts.length !== 2) throw malformedError;
+ host.host = withHostParts.shift();
+ address = withHostParts.shift();
+ }
+
+ if (address.indexOf(':') < 0) {
+ throw malformedError;
+ }
+
+ var addressParts = address.split(':');
+
+ if (addressParts.length !== 2) {
+ throw malformedError;
+ }
+
+ host.host = host.host || addressParts[0];
+ host.port = parseInt(addressParts[1], 10);
+ hosts.push(host);
+ }, []);
+ };
+}
+
+module.exports = makeNodeParser('http.publish_address');
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = {
+ '_default': __webpack_require__(25),
+ '6.2': __webpack_require__(25),
+ '6.1': __webpack_require__(50),
+ '6.0': __webpack_require__(51),
+ '5.6': __webpack_require__(52),
+ '5.5': __webpack_require__(53),
+ '6.x': __webpack_require__(54),
+ 'master': __webpack_require__(55)
+};
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
+ return __webpack_require__(0).merge(spec, {
+ params: {
+ filterPath: {
+ type: 'list',
+ name: 'filter_path'
+ }
+ }
+ });
+});
+
+var namespace = __webpack_require__(1).namespaceFactory;
+
+var api = module.exports = {};
+api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
+/**
+ * Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+ * @param {<>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
+ * @param {<>} params.routing - Specific routing value
+ * @param {<>} params.timeout - Explicit operation timeout
+ * @param {<>} params.type - Default document type for items which don't provide one
+ * @param {<>, <>, <>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
+ * @param {<>, <>, <>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
+ * @param {<>, <>, <>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
+ * @param {<>, <>, <>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
+ * @param {<>} params.pipeline - The pipeline id to preprocess incoming documents with
+ * @param {<>} params.index - Default index for items which don't provide one
+ */
+
+api.bulk = ca({
+ params: {
+ waitForActiveShards: {
+ type: 'string',
+ name: 'wait_for_active_shards'
+ },
+ refresh: {
+ type: 'enum',
+ options: ['true', 'false', 'wait_for', '']
+ },
+ routing: {
+ type: 'string'
+ },
+ timeout: {
+ type: 'time'
+ },
+ type: {
+ type: 'string'
+ },
+ fields: {
+ type: 'list'
+ },
+ _source: {
+ type: 'list'
+ },
+ _sourceExclude: {
+ type: 'list',
+ name: '_source_exclude'
+ },
+ _sourceInclude: {
+ type: 'list',
+ name: '_source_include'
+ },
+ pipeline: {
+ type: 'string'
+ }
+ },
+ urls: [{
+ fmt: '/<%=index%>/<%=type%>/_bulk',
+ req: {
+ index: {
+ type: 'string'
+ },
+ type: {
+ type: 'string'
+ }
+ }
+ }, {
+ fmt: '/<%=index%>/_bulk',
+ req: {
+ index: {
+ type: 'string'
+ }
+ }
+ }, {
+ fmt: '/_bulk'
+ }],
+ needBody: true,
+ bulkBody: true,
+ method: 'POST'
+});
+api.cat = namespace();
+/**
+ * Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.name - A comma-separated list of alias names to return
+ */
+
+api.cat.prototype.aliases = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/aliases/<%=name%>',
+ req: {
+ name: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/aliases'
+ }]
+});
+/**
+ * Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-allocation.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
+ */
+
+api.cat.prototype.allocation = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/allocation/<%=nodeId%>',
+ req: {
+ nodeId: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/allocation'
+ }]
+});
+/**
+ * Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-count.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.index - A comma-separated list of index names to limit the returned information
+ */
+
+api.cat.prototype.count = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/count/<%=index%>',
+ req: {
+ index: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/count'
+ }]
+});
+/**
+ * Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-fielddata.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.fields - A comma-separated list of fields to return the fielddata size
+ */
+
+api.cat.prototype.fielddata = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ },
+ fields: {
+ type: 'list'
+ }
+ },
+ urls: [{
+ fmt: '/_cat/fielddata/<%=fields%>',
+ req: {
+ fields: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/fielddata'
+ }]
+});
+/**
+ * Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-health.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} [params.ts=true] - Set to false to disable timestamping
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.health = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ ts: {
+ type: 'boolean',
+ 'default': true
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/health'
+ }
+});
+/**
+ * Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ */
+
+api.cat.prototype.help = ca({
+ params: {
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ }
+ },
+ url: {
+ fmt: '/_cat'
+ }
+});
+/**
+ * Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-indices.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
+ * @param {<>} params.help - Return help information
+ * @param {<>} params.pri - Set to true to return stats only for primary shards
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.index - A comma-separated list of index names to limit the returned information
+ */
+
+api.cat.prototype.indices = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'm', 'g']
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ health: {
+ type: 'enum',
+ 'default': null,
+ options: ['green', 'yellow', 'red']
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ pri: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/indices/<%=index%>',
+ req: {
+ index: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/indices'
+ }]
+});
+/**
+ * Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-master.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.master = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/master'
+ }
+});
+/**
+ * Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-nodeattrs.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.nodeattrs = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/nodeattrs'
+ }
+});
+/**
+ * Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-nodes.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.fullId - Return the full node ID instead of the shortened version (default: false)
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.nodes = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ fullId: {
+ type: 'boolean',
+ name: 'full_id'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/nodes'
+ }
+});
+/**
+ * Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-pending-tasks.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.pendingTasks = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/pending_tasks'
+ }
+});
+/**
+ * Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-plugins.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.plugins = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/plugins'
+ }
+});
+/**
+ * Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-recovery.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.index - A comma-separated list of index names to limit the returned information
+ */
+
+api.cat.prototype.recovery = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/recovery/<%=index%>',
+ req: {
+ index: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/recovery'
+ }]
+});
+/**
+ * Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-repositories.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ */
+
+api.cat.prototype.repositories = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ local: {
+ type: 'boolean',
+ 'default': false
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ url: {
+ fmt: '/_cat/repositories'
+ }
+});
+/**
+ * Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-segments.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.index - A comma-separated list of index names to limit the returned information
+ */
+
+api.cat.prototype.segments = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/segments/<%=index%>',
+ req: {
+ index: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/segments'
+ }]
+});
+/**
+ * Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-shards.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.bytes - The unit in which to display byte values
+ * @param {<>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.index - A comma-separated list of index names to limit the returned information
+ */
+
+api.cat.prototype.shards = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ bytes: {
+ type: 'enum',
+ options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
+ },
+ local: {
+ type: 'boolean'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/shards/<%=index%>',
+ req: {
+ index: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/shards'
+ }]
+});
+/**
+ * Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-snapshots.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
+ * @param {<>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <>, <>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<>} params.v - Verbose mode. Display column headers
+ * @param {<>, <>, <>} params.repository - Name of repository from which to fetch the snapshot information
+ */
+
+api.cat.prototype.snapshots = ca({
+ params: {
+ format: {
+ type: 'string'
+ },
+ ignoreUnavailable: {
+ type: 'boolean',
+ 'default': false,
+ name: 'ignore_unavailable'
+ },
+ masterTimeout: {
+ type: 'time',
+ name: 'master_timeout'
+ },
+ h: {
+ type: 'list'
+ },
+ help: {
+ type: 'boolean',
+ 'default': false
+ },
+ s: {
+ type: 'list'
+ },
+ v: {
+ type: 'boolean',
+ 'default': false
+ }
+ },
+ urls: [{
+ fmt: '/_cat/snapshots/<%=repository%>',
+ req: {
+ repository: {
+ type: 'list'
+ }
+ }
+ }, {
+ fmt: '/_cat/snapshots'
+ }]
+});
+/**
+ * Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/tasks.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<>, <>, <>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
+ * @param {<>, <>, <>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
+ * @param {<>} params.detailed - Return detailed task information (default: false)
+ * @param {<>} params.parentNode - Return tasks with specified parent node.
+ * @param {<>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
+ * @param {<>, <>, <>} params.h - Comma-separated list of column names to display
+ * @param {<>} params.help - Return help information
+ * @param {<>, <