Izmjenjena struktura, dodan backand

web/node_modules/portfinder/LICENSE

@@ -0,0 +1,22 @@
+node-portfinder
+
+Copyright (c) 2012 Charlie Robbins
+
+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.

web/node_modules/portfinder/README.md

@@ -0,0 +1,55 @@
+# node-portfinder [![Build Status](https://api.travis-ci.org/indexzero/node-portfinder.svg)](https://travis-ci.org/indexzero/node-portfinder)
+
+## Installation
+
+``` bash
+  $ [sudo] npm install portfinder
+```
+
+## Usage
+The `portfinder` module has a simple interface:
+
+``` js
+  var portfinder = require('portfinder');
+
+  portfinder.getPort(function (err, port) {
+    //
+    // `port` is guaranteed to be a free port
+    // in this scope.
+    //
+  });
+```
+
+Or with promise (if Promise are supported) :
+
+``` js
+  const portfinder = require('portfinder');
+
+  portfinder.getPortPromise()
+    .then((port) => {
+        //
+        // `port` is guaranteed to be a free port
+        // in this scope.
+        //
+    })
+    .catch((err) => {
+        //
+        // Could not get a free port, `err` contains the reason.
+        //
+    });
+```
+
+If `portfinder.getPortPromise()` is called on a Node version without Promise (<4), it will throw an Error unless [Bluebird](http://bluebirdjs.com/docs/getting-started.html) or any Promise pollyfill is used.
+
+By default `portfinder` will start searching from `8000`. To change this simply set `portfinder.basePort`.
+
+## Run Tests
+``` bash
+  $ npm test
+```
+
+#### Author: [Charlie Robbins][0]
+#### Maintainer: [Erik Trom][1]
+#### License: MIT/X11
+[0]: http://nodejitsu.com
+[1]: https://github.com/eriktrom

web/node_modules/portfinder/lib/portfinder.d.ts

@@ -0,0 +1,33 @@
+/**
+ * portfinder.js typescript definitions.
+ *
+ * (C) 2011, Charlie Robbins
+ */
+
+type PortfinderCallback = (err: Error, port: number) => void;
+
+interface PortFinderOptions{
+  /**
+   * Host to find available port on.
+   */
+  host?: string;
+  /**
+   * Minimum port (takes precedence over `basePort`).
+   */
+  port?: number;
+}
+
+/**
+ * The lowest port to begin any port search from.
+ */
+export let basePort: number;
+
+/**
+ * Responds with a unbound port on the current machine.
+ */
+export function getPort(callback: PortfinderCallback): void;
+export function getPort(options: PortFinderOptions, callback: PortfinderCallback): void;
+/**
+ * Responds a promise of an unbound port on the current machine.
+ */
+export function getPortPromise(options?: PortFinderOptions): Promise<number>;

web/node_modules/portfinder/lib/portfinder.js

@@ -0,0 +1,454 @@
+/*
+ * portfinder.js: A simple tool to find an open port on the current machine.
+ *
+ * (C) 2011, Charlie Robbins
+ *
+ */
+
+"use strict";
+
+var fs = require('fs'),
+    os = require('os'),
+    net = require('net'),
+    path = require('path'),
+    async = require('async'),
+    debug = require('debug'),
+    mkdirp = require('mkdirp').mkdirp;
+
+var debugTestPort = debug('portfinder:testPort'),
+    debugGetPort = debug('portfinder:getPort'),
+    debugDefaultHosts = debug('portfinder:defaultHosts');
+
+var internals = {};
+
+internals.testPort = function(options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+
+  options.port   = options.port   || exports.basePort;
+  options.host   = options.host   || null;
+  options.server = options.server || net.createServer(function () {
+    //
+    // Create an empty listener for the port testing server.
+    //
+  });
+
+  debugTestPort("entered testPort(): trying", options.host, "port", options.port);
+
+  function onListen () {
+    debugTestPort("done w/ testPort(): OK", options.host, "port", options.port);
+
+        options.server.removeListener('error', onError);
+        options.server.close();
+      callback(null, options.port);
+  }
+
+  function onError (err) {
+    debugTestPort("done w/ testPort(): failed", options.host, "w/ port", options.port, "with error", err.code);
+
+    options.server.removeListener('listening', onListen);
+
+    if (err.code !== 'EADDRINUSE' && err.code !== 'EACCES') {
+      return callback(err);
+    }
+
+    internals.testPort({
+      port: exports.nextPort(options.port),
+      host: options.host,
+      server: options.server
+    }, callback);
+  }
+
+  options.server.once('error', onError);
+  options.server.once('listening', onListen);
+  options.server.listen(options.port, options.host);
+};
+
+//
+// ### @basePort {Number}
+// The lowest port to begin any port search from
+//
+exports.basePort = 8000;
+
+//
+// ### @basePath {string}
+// Default path to begin any socket search from
+//
+exports.basePath = '/tmp/portfinder'
+
+//
+// ### function getPort (options, callback)
+// #### @options {Object} Settings to use when finding the necessary port
+// #### @callback {function} Continuation to respond to when complete.
+// Responds with a unbound port on the current machine.
+//
+exports.getPort = function (options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+
+  if (options.host) {
+
+    var hasUserGivenHost;
+    for (var i = 0; i < exports._defaultHosts.length; i++) {
+      if (exports._defaultHosts[i] === options.host) {
+        hasUserGivenHost = true;
+        break;
+      }
+    }
+
+    if (!hasUserGivenHost) {
+      exports._defaultHosts.push(options.host);
+    }
+
+  }
+
+  var openPorts = [], currentHost;
+  return async.eachSeries(exports._defaultHosts, function(host, next) {
+    debugGetPort("in eachSeries() iteration callback: host is", host);
+
+    return internals.testPort({ host: host, port: options.port }, function(err, port) {
+      if (err) {
+        debugGetPort("in eachSeries() iteration callback testPort() callback", "with an err:", err.code);
+        currentHost = host;
+        return next(err);
+      } else {
+        debugGetPort("in eachSeries() iteration callback testPort() callback",
+                    "with a success for port", port);
+        openPorts.push(port);
+        return next();
+      }
+    });
+  }, function(err) {
+
+    if (err) {
+      debugGetPort("in eachSeries() result callback: err is", err);
+      // If we get EADDRNOTAVAIL it means the host is not bindable, so remove it
+      // from exports._defaultHosts and start over. For ubuntu, we use EINVAL for the same
+      if (err.code === 'EADDRNOTAVAIL' || err.code === 'EINVAL') {
+        if (options.host === currentHost) {
+          // if bad address matches host given by user, tell them
+          //
+          // NOTE: We may need to one day handle `my-non-existent-host.local` if users
+          // report frustration with passing in hostnames that DONT map to bindable
+          // hosts, without showing them a good error.
+          var msg = 'Provided host ' + options.host + ' could NOT be bound. Please provide a different host address or hostname';
+          return callback(Error(msg));
+        }
+
+        var idx = exports._defaultHosts.indexOf(currentHost);
+        exports._defaultHosts.splice(idx, 1);
+        return exports.getPort(options, callback);
+      } else {
+        // error is not accounted for, file ticket, handle special case
+        return callback(err);
+      }
+    }
+
+    // sort so we can compare first host to last host
+    openPorts.sort(function(a, b) {
+      return a - b;
+    });
+
+    debugGetPort("in eachSeries() result callback: openPorts is", openPorts);
+
+    if (openPorts[0] === openPorts[openPorts.length-1]) {
+      // if first === last, we found an open port
+      return callback(null, openPorts[0]);
+    } else {
+      // otherwise, try again, using sorted port, aka, highest open for >= 1 host
+      return exports.getPort({ port: openPorts.pop(), host: options.host }, callback);
+    }
+
+  });
+};
+
+//
+// ### function getPortPromise (options)
+// #### @options {Object} Settings to use when finding the necessary port
+// Responds a promise to an unbound port on the current machine.
+//
+exports.getPortPromise = function (options) {
+  if (typeof Promise !== 'function') {
+    throw Error('Native promise support is not available in this version of node.' +
+      'Please install a polyfill and assign Promise to global.Promise before calling this method');
+  }
+  if (!options) {
+    options = {};
+  }
+  return new Promise(function(resolve, reject) {
+    exports.getPort(options, function(err, port) {
+      if (err) {
+        return reject(err);
+      }
+      resolve(port);
+    });
+  });
+}
+
+//
+// ### function getPorts (count, options, callback)
+// #### @count {Number} The number of ports to find
+// #### @options {Object} Settings to use when finding the necessary port
+// #### @callback {function} Continuation to respond to when complete.
+// Responds with an array of unbound ports on the current machine.
+//
+exports.getPorts = function (count, options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+
+  var lastPort = null;
+  async.timesSeries(count, function(index, asyncCallback) {
+    if (lastPort) {
+      options.port = exports.nextPort(lastPort);
+    }
+
+    exports.getPort(options, function (err, port) {
+      if (err) {
+        asyncCallback(err);
+      } else {
+        lastPort = port;
+        asyncCallback(null, port);
+      }
+    });
+  }, callback);
+};
+
+//
+// ### function getSocket (options, callback)
+// #### @options {Object} Settings to use when finding the necessary port
+// #### @callback {function} Continuation to respond to when complete.
+// Responds with a unbound socket using the specified directory and base
+// name on the current machine.
+//
+exports.getSocket = function (options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+
+  options.mod  = options.mod    || parseInt(755, 8);
+  options.path = options.path   || exports.basePath + '.sock';
+
+  //
+  // Tests the specified socket
+  //
+  function testSocket () {
+    fs.stat(options.path, function (err) {
+      //
+      // If file we're checking doesn't exist (thus, stating it emits ENOENT),
+      // we should be OK with listening on this socket.
+      //
+      if (err) {
+        if (err.code == 'ENOENT') {
+          callback(null, options.path);
+        }
+        else {
+          callback(err);
+        }
+      }
+      else {
+        //
+        // This file exists, so it isn't possible to listen on it. Lets try
+        // next socket.
+        //
+        options.path = exports.nextSocket(options.path);
+        exports.getSocket(options, callback);
+      }
+    });
+  }
+
+  //
+  // Create the target `dir` then test connection
+  // against the socket.
+  //
+  function createAndTestSocket (dir) {
+    mkdirp(dir, options.mod, function (err) {
+      if (err) {
+        return callback(err);
+      }
+
+      options.exists = true;
+      testSocket();
+    });
+  }
+
+  //
+  // Check if the parent directory of the target
+  // socket path exists. If it does, test connection
+  // against the socket. Otherwise, create the directory
+  // then test connection.
+  //
+  function checkAndTestSocket () {
+    var dir = path.dirname(options.path);
+
+    fs.stat(dir, function (err, stats) {
+      if (err || !stats.isDirectory()) {
+        return createAndTestSocket(dir);
+      }
+
+      options.exists = true;
+      testSocket();
+    });
+  }
+
+  //
+  // If it has been explicitly stated that the
+  // target `options.path` already exists, then
+  // simply test the socket.
+  //
+  return options.exists
+    ? testSocket()
+    : checkAndTestSocket();
+};
+
+//
+// ### function nextPort (port)
+// #### @port {Number} Port to increment from.
+// Gets the next port in sequence from the
+// specified `port`.
+//
+exports.nextPort = function (port) {
+  return port + 1;
+};
+
+//
+// ### function nextSocket (socketPath)
+// #### @socketPath {string} Path to increment from
+// Gets the next socket path in sequence from the
+// specified `socketPath`.
+//
+exports.nextSocket = function (socketPath) {
+  var dir = path.dirname(socketPath),
+      name = path.basename(socketPath, '.sock'),
+      match = name.match(/^([a-zA-z]+)(\d*)$/i),
+      index = parseInt(match[2]),
+      base = match[1];
+
+  if (isNaN(index)) {
+    index = 0;
+  }
+
+  index += 1;
+  return path.join(dir, base + index + '.sock');
+};
+
+/**
+ * @desc List of internal hostnames provided by your machine. A user
+ *       provided hostname may also be provided when calling portfinder.getPort,
+ *       which would then be added to the default hosts we lookup and return here.
+ *
+ * @return {array}
+ *
+ * Long Form Explantion:
+ *
+ *    - Input: (os.networkInterfaces() w/ MacOS 10.11.5+ and running a VM)
+ *
+ *        { lo0:
+ *         [ { address: '::1',
+ *             netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+ *             family: 'IPv6',
+ *             mac: '00:00:00:00:00:00',
+ *             scopeid: 0,
+ *             internal: true },
+ *           { address: '127.0.0.1',
+ *             netmask: '255.0.0.0',
+ *             family: 'IPv4',
+ *             mac: '00:00:00:00:00:00',
+ *             internal: true },
+ *           { address: 'fe80::1',
+ *             netmask: 'ffff:ffff:ffff:ffff::',
+ *             family: 'IPv6',
+ *             mac: '00:00:00:00:00:00',
+ *             scopeid: 1,
+ *             internal: true } ],
+ *        en0:
+ *         [ { address: 'fe80::a299:9bff:fe17:766d',
+ *             netmask: 'ffff:ffff:ffff:ffff::',
+ *             family: 'IPv6',
+ *             mac: 'a0:99:9b:17:76:6d',
+ *             scopeid: 4,
+ *             internal: false },
+ *           { address: '10.0.1.22',
+ *             netmask: '255.255.255.0',
+ *             family: 'IPv4',
+ *             mac: 'a0:99:9b:17:76:6d',
+ *             internal: false } ],
+ *        awdl0:
+ *         [ { address: 'fe80::48a8:37ff:fe34:aaef',
+ *             netmask: 'ffff:ffff:ffff:ffff::',
+ *             family: 'IPv6',
+ *             mac: '4a:a8:37:34:aa:ef',
+ *             scopeid: 8,
+ *             internal: false } ],
+ *        vnic0:
+ *         [ { address: '10.211.55.2',
+ *             netmask: '255.255.255.0',
+ *             family: 'IPv4',
+ *             mac: '00:1c:42:00:00:08',
+ *             internal: false } ],
+ *        vnic1:
+ *         [ { address: '10.37.129.2',
+ *             netmask: '255.255.255.0',
+ *             family: 'IPv4',
+ *             mac: '00:1c:42:00:00:09',
+ *             internal: false } ] }
+ *
+ *    - Output:
+ *
+ *         [
+ *          '0.0.0.0',
+ *          '::1',
+ *          '127.0.0.1',
+ *          'fe80::1',
+ *          '10.0.1.22',
+ *          'fe80::48a8:37ff:fe34:aaef',
+ *          '10.211.55.2',
+ *          '10.37.129.2'
+ *         ]
+ *
+ *     Note we export this so we can use it in our tests, otherwise this API is private
+ */
+exports._defaultHosts = (function() {
+  var interfaces = {};
+  try{
+    interfaces = os.networkInterfaces();
+  }
+  catch(e) {
+    // As of October 2016, Windows Subsystem for Linux (WSL) does not support
+    // the os.networkInterfaces() call and throws instead. For this platform,
+    // assume 0.0.0.0 as the only address
+    //
+    // - https://github.com/Microsoft/BashOnWindows/issues/468
+    //
+    // - Workaround is a mix of good work from the community:
+    //   - https://github.com/indexzero/node-portfinder/commit/8d7e30a648ff5034186551fa8a6652669dec2f2f
+    //   - https://github.com/yarnpkg/yarn/pull/772/files
+    if (e.syscall === 'uv_interface_addresses') {
+      // swallow error because we're just going to use defaults
+      // documented @ https://github.com/nodejs/node/blob/4b65a65e75f48ff447cabd5500ce115fb5ad4c57/doc/api/net.md#L231
+    } else {
+      throw e;
+    }
+  }
+
+  var interfaceNames = Object.keys(interfaces),
+      hiddenButImportantHost = '0.0.0.0', // !important - dont remove, hence the naming :)
+      results = [hiddenButImportantHost];
+  for (var i = 0; i < interfaceNames.length; i++) {
+    var _interface = interfaces[interfaceNames[i]];
+    for (var j = 0; j < _interface.length; j++) {
+      var curr = _interface[j];
+      results.push(curr.address);
+    }
+  }
+
+  debugDefaultHosts("exports._defaultHosts is: %o", results);
+
+  return results;
+}());

web/node_modules/portfinder/node_modules/async/CHANGELOG.md

@@ -0,0 +1,125 @@
+# v1.5.2
+- Allow using `"consructor"` as an argument in `memoize` (#998)
+- Give a better error messsage when `auto` dependency checking fails (#994)
+- Various doc updates (#936, #956, #979, #1002)
+
+# v1.5.1
+- Fix issue with `pause` in `queue` with concurrency enabled (#946)
+- `while` and `until` now pass the final result to callback (#963)
+- `auto` will properly handle concurrency when there is no callback (#966)
+- `auto` will now  properly stop execution when an error occurs (#988, #993)
+- Various doc fixes (#971, #980)
+
+# v1.5.0
+
+- Added `transform`, analogous to [`_.transform`](http://lodash.com/docs#transform) (#892)
+- `map` now returns an object when an object is passed in, rather than array with non-numeric keys. `map` will begin always returning an array with numeric indexes in the next major release. (#873)
+- `auto` now accepts an optional `concurrency` argument to limit the number of  running tasks (#637)
+- Added `queue#workersList()`, to retrieve the list  of currently running tasks. (#891)
+- Various code simplifications (#896, #904)
+- Various doc fixes :scroll: (#890, #894, #903, #905, #912)
+
+# v1.4.2
+
+- Ensure coverage files don't get published on npm (#879)
+
+# v1.4.1
+
+- Add in overlooked `detectLimit` method (#866)
+- Removed unnecessary files from npm releases (#861)
+- Removed usage of a reserved word to prevent :boom: in older environments (#870)
+
+# v1.4.0
+
+- `asyncify` now supports promises (#840)
+- Added `Limit` versions of `filter` and `reject` (#836)
+- Add `Limit` versions of `detect`, `some` and `every` (#828, #829)
+- `some`, `every` and `detect` now short circuit early (#828, #829)
+- Improve detection of the global object (#804), enabling use in WebWorkers
+- `whilst` now called with arguments from iterator (#823)
+- `during` now gets called with arguments from iterator (#824)
+- Code simplifications and optimizations aplenty ([diff](https://github.com/caolan/async/compare/v1.3.0...v1.4.0))
+
+
+# v1.3.0
+
+New Features:
+- Added `constant`
+- Added `asyncify`/`wrapSync` for making sync functions work with callbacks. (#671, #806)
+- Added `during` and `doDuring`, which are like `whilst` with an async truth test. (#800)
+- `retry` now accepts an `interval` parameter to specify a delay between retries. (#793)
+- `async` should work better in Web Workers due to better `root` detection (#804)
+- Callbacks are now optional in `whilst`, `doWhilst`, `until`, and `doUntil` (#642)
+- Various internal updates (#786, #801, #802, #803)
+- Various doc fixes (#790, #794)
+
+Bug Fixes:
+- `cargo` now exposes the `payload` size, and `cargo.payload` can be changed on the fly after the `cargo` is created. (#740, #744, #783)
+
+
+# v1.2.1
+
+Bug Fix:
+
+- Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array.  Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores.  In 2.0.0, it will be called on the next tick.  (#782)
+
+
+# v1.2.0
+
+New Features:
+
+- Added `timesLimit` (#743)
+- `concurrency` can be changed after initialization in `queue` by setting `q.concurrency`.  The new concurrency will be reflected the next time a task is processed. (#747, #772)
+
+Bug Fixes:
+
+- Fixed a regression in `each` and family with empty arrays that have additional properties. (#775, #777)
+
+
+# v1.1.1
+
+Bug Fix:
+
+- Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array.  Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores.  In 2.0.0, it will be called on the next tick.  (#782) 
+
+
+# v1.1.0
+
+New Features:
+
+- `cargo` now supports all of the same methods and event callbacks as `queue`.
+- Added `ensureAsync` - A wrapper that ensures an async function calls its callback on a later tick. (#769)
+- Optimized `map`, `eachOf`, and `waterfall` families of functions
+- Passing a `null` or `undefined` array to `map`, `each`, `parallel` and families will be treated as an empty array (#667).
+- The callback is now optional for the composed results of `compose` and `seq`. (#618)
+- Reduced file size by 4kb, (minified version by 1kb) 
+- Added code coverage through `nyc` and `coveralls` (#768)
+
+Bug Fixes:
+
+- `forever` will no longer stack overflow with a synchronous iterator (#622)
+- `eachLimit` and other limit functions will stop iterating once an error occurs (#754)
+- Always pass `null` in callbacks when there is no error (#439)
+- Ensure proper conditions when calling `drain()` after pushing an empty data set to a queue (#668)
+- `each` and family will properly handle an empty array (#578)
+- `eachSeries` and family will finish if the underlying array is modified during execution (#557)
+- `queue` will throw if a non-function is passed to `q.push()` (#593)
+- Doc fixes (#629, #766)
+
+
+# v1.0.0
+
+No known breaking changes, we are simply complying with semver from here on out.
+
+Changes:
+
+- Start using a changelog!
+- Add `forEachOf` for iterating over Objects (or to iterate Arrays with indexes available) (#168 #704 #321)
+- Detect deadlocks in `auto` (#663)
+- Better support for require.js (#527)
+- Throw if queue created with concurrency `0` (#714)
+- Fix unneeded iteration in `queue.resume()` (#758)
+- Guard against timer mocking overriding `setImmediate` (#609 #611)
+- Miscellaneous doc fixes (#542 #596 #615 #628 #631 #690 #729)
+- Use single noop function internally (#546)
+- Optimize internal `_each`, `_map` and `_keys` functions.

web/node_modules/portfinder/node_modules/async/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2014 Caolan McMahon
+
+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.

web/node_modules/portfinder/node_modules/async/package.json

@@ -0,0 +1,113 @@
+{
+  "_from": "async@^1.5.2",
+  "_id": "async@1.5.2",
+  "_inBundle": false,
+  "_integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=",
+  "_location": "/portfinder/async",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "async@^1.5.2",
+    "name": "async",
+    "escapedName": "async",
+    "rawSpec": "^1.5.2",
+    "saveSpec": null,
+    "fetchSpec": "^1.5.2"
+  },
+  "_requiredBy": [
+    "/portfinder"
+  ],
+  "_resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
+  "_shasum": "ec6a61ae56480c0c3cb241c95618e20892f9672a",
+  "_spec": "async@^1.5.2",
+  "_where": "/home/bilal/Saburly/slucajna-televizija/node_modules/portfinder",
+  "author": {
+    "name": "Caolan McMahon"
+  },
+  "bugs": {
+    "url": "https://github.com/caolan/async/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Higher-order functions and common patterns for asynchronous code",
+  "devDependencies": {
+    "benchmark": "github:bestiejs/benchmark.js",
+    "bluebird": "^2.9.32",
+    "chai": "^3.1.0",
+    "coveralls": "^2.11.2",
+    "es6-promise": "^2.3.0",
+    "jscs": "^1.13.1",
+    "jshint": "~2.8.0",
+    "karma": "^0.13.2",
+    "karma-browserify": "^4.2.1",
+    "karma-firefox-launcher": "^0.1.6",
+    "karma-mocha": "^0.2.0",
+    "karma-mocha-reporter": "^1.0.2",
+    "lodash": "^3.9.0",
+    "mkdirp": "~0.5.1",
+    "mocha": "^2.2.5",
+    "native-promise-only": "^0.8.0-a",
+    "nodeunit": ">0.0.0",
+    "nyc": "^2.1.0",
+    "rsvp": "^3.0.18",
+    "semver": "^4.3.6",
+    "uglify-js": "~2.4.0",
+    "xyz": "^0.5.0",
+    "yargs": "~3.9.1"
+  },
+  "files": [
+    "lib",
+    "dist/async.js",
+    "dist/async.min.js"
+  ],
+  "homepage": "https://github.com/caolan/async#readme",
+  "jam": {
+    "main": "lib/async.js",
+    "include": [
+      "lib/async.js",
+      "README.md",
+      "LICENSE"
+    ],
+    "categories": [
+      "Utilities"
+    ]
+  },
+  "keywords": [
+    "async",
+    "callback",
+    "utility",
+    "module"
+  ],
+  "license": "MIT",
+  "main": "lib/async.js",
+  "name": "async",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/caolan/async.git"
+  },
+  "scripts": {
+    "coverage": "nyc npm test && nyc report",
+    "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls",
+    "lint": "jshint lib/*.js test/*.js perf/*.js && jscs lib/*.js test/*.js perf/*.js",
+    "mocha-browser-test": "karma start",
+    "mocha-node-test": "mocha mocha_test/",
+    "mocha-test": "npm run mocha-node-test && npm run mocha-browser-test",
+    "nodeunit-test": "nodeunit test/test-async.js",
+    "test": "npm run-script lint && npm run nodeunit-test && npm run mocha-test"
+  },
+  "spm": {
+    "main": "lib/async.js"
+  },
+  "version": "1.5.2",
+  "volo": {
+    "main": "lib/async.js",
+    "ignore": [
+      "**/.*",
+      "node_modules",
+      "bower_components",
+      "test",
+      "tests"
+    ]
+  }
+}

web/node_modules/portfinder/package.json

@@ -0,0 +1,68 @@
+{
+  "_from": "portfinder@^1.0.9",
+  "_id": "portfinder@1.0.13",
+  "_inBundle": false,
+  "_integrity": "sha1-uzLs2HwnEErm7kS1o8y/Drsa7ek=",
+  "_location": "/portfinder",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "portfinder@^1.0.9",
+    "name": "portfinder",
+    "escapedName": "portfinder",
+    "rawSpec": "^1.0.9",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.9"
+  },
+  "_requiredBy": [
+    "/webpack-dev-server"
+  ],
+  "_resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.13.tgz",
+  "_shasum": "bb32ecd87c27104ae6ee44b5a3ccbf0ebb1aede9",
+  "_spec": "portfinder@^1.0.9",
+  "_where": "/home/bilal/Saburly/slucajna-televizija/node_modules/webpack-dev-server",
+  "author": {
+    "name": "Charlie Robbins",
+    "email": "charlie.robbins@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/indexzero/node-portfinder/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "async": "^1.5.2",
+    "debug": "^2.2.0",
+    "mkdirp": "0.5.x"
+  },
+  "deprecated": false,
+  "description": "A simple tool to find an open port on the current machine",
+  "devDependencies": {
+    "glob": "^6.0.4",
+    "vows": "0.8.0"
+  },
+  "engines": {
+    "node": ">= 0.12.0"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/indexzero/node-portfinder#readme",
+  "keywords": [
+    "http",
+    "ports",
+    "utilities"
+  ],
+  "license": "MIT",
+  "main": "./lib/portfinder",
+  "name": "portfinder",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/indexzero/node-portfinder.git"
+  },
+  "scripts": {
+    "test": "vows test/*-test.js --spec"
+  },
+  "types": "./lib/portfinder.d.ts",
+  "version": "1.0.13"
+}