Added logging, changed some directory structure

goTorrentWebUI/node_modules/react-scripts/node_modules/util/.npmignore

@@ -0,0 +1 @@
+node_modules

goTorrentWebUI/node_modules/react-scripts/node_modules/util/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+- '0.8'
+- '0.10'
+env:
+  global:
+  - secure: AdUubswCR68/eGD+WWjwTHgFbelwQGnNo81j1IOaUxKw+zgFPzSnFEEtDw7z98pWgg7p9DpCnyzzSnSllP40wq6AG19OwyUJjSLoZK57fp+r8zwTQwWiSqUgMu2YSMmKJPIO/aoSGpRQXT+L1nRrHoUJXgFodyIZgz40qzJeZjc=
+  - secure: heQuxPVsQ7jBbssoVKimXDpqGjQFiucm6W5spoujmspjDG7oEcHD9ANo9++LoRPrsAmNx56SpMK5fNfVmYediw6SvhXm4Mxt56/fYCrLDBtgGG+1neCeffAi8z1rO8x48m77hcQ6YhbUL5R9uBimUjMX92fZcygAt8Rg804zjFo=

goTorrentWebUI/node_modules/react-scripts/node_modules/util/.zuul.yml

@@ -0,0 +1,10 @@
+ui: mocha-qunit
+browsers:
+  - name: chrome
+    version: 27..latest
+  - name: firefox
+    version: latest
+  - name: safari
+    version: latest
+  - name: ie
+    version: 9..latest

goTorrentWebUI/node_modules/react-scripts/node_modules/util/LICENSE

@@ -0,0 +1,18 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.

goTorrentWebUI/node_modules/react-scripts/node_modules/util/README.md

@@ -0,0 +1,15 @@
+# util
+
+[![Build Status](https://travis-ci.org/defunctzombie/node-util.png?branch=master)](https://travis-ci.org/defunctzombie/node-util)
+
+node.js [util](http://nodejs.org/api/util.html) module as a module
+
+## install via [npm](npmjs.org)
+
+```shell
+npm install util
+```
+
+## browser support
+
+This module also works in modern browsers. If you need legacy browser support you will need to polyfill ES5 features.

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/LICENSE

@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/README.md

@@ -0,0 +1,42 @@
+Browser-friendly inheritance fully compatible with standard node.js
+[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
+
+This package exports standard `inherits` from node.js `util` module in
+node environment, but also provides alternative browser-friendly
+implementation through [browser
+field](https://gist.github.com/shtylman/4339901). Alternative
+implementation is a literal copy of standard one located in standalone
+module to avoid requiring of `util`. It also has a shim for old
+browsers with no `Object.create` support.
+
+While keeping you sure you are using standard `inherits`
+implementation in node.js environment, it allows bundlers such as
+[browserify](https://github.com/substack/node-browserify) to not
+include full `util` package to your client code if all you need is
+just `inherits` function. It worth, because browser shim for `util`
+package is large and `inherits` is often the single function you need
+from it.
+
+It's recommended to use this package instead of
+`require('util').inherits` for any code that has chances to be used
+not only in node.js but in browser too.
+
+## usage
+
+```js
+var inherits = require('inherits');
+// then use exactly as the standard one
+```
+
+## note on version ~1.0
+
+Version ~1.0 had completely different motivation and is not compatible
+neither with 2.0 nor with standard node.js `inherits`.
+
+If you are using version ~1.0 and planning to switch to ~2.0, be
+careful:
+
+* new version uses `super_` instead of `super` for referencing
+  superclass
+* new version overwrites current prototype while old one preserves any
+  existing fields on it

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/inherits.js

@@ -0,0 +1 @@
+module.exports = require('util').inherits

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,23 @@
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/package.json

@@ -0,0 +1,57 @@
+{
+  "_args": [
+    [
+      "inherits@2.0.1",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "inherits@2.0.1",
+  "_id": "inherits@2.0.1",
+  "_inBundle": false,
+  "_integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=",
+  "_location": "/react-scripts/util/inherits",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "inherits@2.0.1",
+    "name": "inherits",
+    "escapedName": "inherits",
+    "rawSpec": "2.0.1",
+    "saveSpec": null,
+    "fetchSpec": "2.0.1"
+  },
+  "_requiredBy": [
+    "/react-scripts/util"
+  ],
+  "_resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz",
+  "_spec": "2.0.1",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "browser": "./inherits_browser.js",
+  "bugs": {
+    "url": "https://github.com/isaacs/inherits/issues"
+  },
+  "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
+  "homepage": "https://github.com/isaacs/inherits#readme",
+  "keywords": [
+    "inheritance",
+    "class",
+    "klass",
+    "oop",
+    "object-oriented",
+    "inherits",
+    "browser",
+    "browserify"
+  ],
+  "license": "ISC",
+  "main": "./inherits.js",
+  "name": "inherits",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/inherits.git"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "version": "2.0.1"
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/node_modules/inherits/test.js

@@ -0,0 +1,25 @@
+var inherits = require('./inherits.js')
+var assert = require('assert')
+
+function test(c) {
+  assert(c.constructor === Child)
+  assert(c.constructor.super_ === Parent)
+  assert(Object.getPrototypeOf(c) === Child.prototype)
+  assert(Object.getPrototypeOf(Object.getPrototypeOf(c)) === Parent.prototype)
+  assert(c instanceof Child)
+  assert(c instanceof Parent)
+}
+
+function Child() {
+  Parent.call(this)
+  test(this)
+}
+
+function Parent() {}
+
+inherits(Child, Parent)
+
+var c = new Child
+test(c)
+
+console.log('ok')

goTorrentWebUI/node_modules/react-scripts/node_modules/util/package.json

@@ -0,0 +1,63 @@
+{
+  "_args": [
+    [
+      "util@0.10.3",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "util@0.10.3",
+  "_id": "util@0.10.3",
+  "_inBundle": false,
+  "_integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=",
+  "_location": "/react-scripts/util",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "util@0.10.3",
+    "name": "util",
+    "escapedName": "util",
+    "rawSpec": "0.10.3",
+    "saveSpec": null,
+    "fetchSpec": "0.10.3"
+  },
+  "_requiredBy": [
+    "/react-scripts/assert",
+    "/react-scripts/node-libs-browser"
+  ],
+  "_resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz",
+  "_spec": "0.10.3",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Joyent",
+    "url": "http://www.joyent.com"
+  },
+  "browser": {
+    "./support/isBuffer.js": "./support/isBufferBrowser.js"
+  },
+  "bugs": {
+    "url": "https://github.com/defunctzombie/node-util/issues"
+  },
+  "dependencies": {
+    "inherits": "2.0.1"
+  },
+  "description": "Node.JS util module",
+  "devDependencies": {
+    "zuul": "~1.0.9"
+  },
+  "homepage": "https://github.com/defunctzombie/node-util",
+  "keywords": [
+    "util"
+  ],
+  "license": "MIT",
+  "main": "./util.js",
+  "name": "util",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/defunctzombie/node-util.git"
+  },
+  "scripts": {
+    "test": "node test/node/*.js && zuul test/browser/*.js"
+  },
+  "version": "0.10.3"
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/support/isBuffer.js

@@ -0,0 +1,3 @@
+module.exports = function isBuffer(arg) {
+  return arg instanceof Buffer;
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/support/isBufferBrowser.js

@@ -0,0 +1,6 @@
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/browser/inspect.js

@@ -0,0 +1,41 @@
+// 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 assert = require('assert');
+var util = require('../../');
+
+suite('inspect');
+
+test('util.inspect - test for sparse array', function () {
+  var a = ['foo', 'bar', 'baz'];
+  assert.equal(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
+  delete a[1];
+  assert.equal(util.inspect(a), '[ \'foo\', , \'baz\' ]');
+  assert.equal(util.inspect(a, true), '[ \'foo\', , \'baz\', [length]: 3 ]');
+  assert.equal(util.inspect(new Array(5)), '[ , , , ,  ]');
+});
+
+test('util.inspect -  exceptions should print the error message, not \'{}\'', function () {
+  assert.equal(util.inspect(new Error()), '[Error]');
+  assert.equal(util.inspect(new Error('FAIL')), '[Error: FAIL]');
+  assert.equal(util.inspect(new TypeError('FAIL')), '[TypeError: FAIL]');
+  assert.equal(util.inspect(new SyntaxError('FAIL')), '[SyntaxError: FAIL]');
+});

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/browser/is.js

@@ -0,0 +1,91 @@
+// 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 assert = require('assert');
+
+var util = require('../../');
+
+suite('is');
+
+test('util.isArray', function () {
+  assert.equal(true, util.isArray([]));
+  assert.equal(true, util.isArray(Array()));
+  assert.equal(true, util.isArray(new Array()));
+  assert.equal(true, util.isArray(new Array(5)));
+  assert.equal(true, util.isArray(new Array('with', 'some', 'entries')));
+  assert.equal(false, util.isArray({}));
+  assert.equal(false, util.isArray({ push: function() {} }));
+  assert.equal(false, util.isArray(/regexp/));
+  assert.equal(false, util.isArray(new Error()));
+  assert.equal(false, util.isArray(Object.create(Array.prototype)));
+});
+
+test('util.isRegExp', function () {
+  assert.equal(true, util.isRegExp(/regexp/));
+  assert.equal(true, util.isRegExp(RegExp()));
+  assert.equal(true, util.isRegExp(new RegExp()));
+  assert.equal(false, util.isRegExp({}));
+  assert.equal(false, util.isRegExp([]));
+  assert.equal(false, util.isRegExp(new Date()));
+  assert.equal(false, util.isRegExp(Object.create(RegExp.prototype)));
+});
+
+test('util.isDate', function () {
+  assert.equal(true, util.isDate(new Date()));
+  assert.equal(true, util.isDate(new Date(0)));
+  assert.equal(false, util.isDate(Date()));
+  assert.equal(false, util.isDate({}));
+  assert.equal(false, util.isDate([]));
+  assert.equal(false, util.isDate(new Error()));
+  assert.equal(false, util.isDate(Object.create(Date.prototype)));
+});
+
+test('util.isError', function () {
+  assert.equal(true, util.isError(new Error()));
+  assert.equal(true, util.isError(new TypeError()));
+  assert.equal(true, util.isError(new SyntaxError()));
+  assert.equal(false, util.isError({}));
+  assert.equal(false, util.isError({ name: 'Error', message: '' }));
+  assert.equal(false, util.isError([]));
+  assert.equal(true, util.isError(Object.create(Error.prototype)));
+});
+
+test('util._extend', function () {
+  assert.deepEqual(util._extend({a:1}),             {a:1});
+  assert.deepEqual(util._extend({a:1}, []),         {a:1});
+  assert.deepEqual(util._extend({a:1}, null),       {a:1});
+  assert.deepEqual(util._extend({a:1}, true),       {a:1});
+  assert.deepEqual(util._extend({a:1}, false),      {a:1});
+  assert.deepEqual(util._extend({a:1}, {b:2}),      {a:1, b:2});
+  assert.deepEqual(util._extend({a:1, b:2}, {b:3}), {a:1, b:3});
+});
+
+test('util.isBuffer', function () {
+  assert.equal(true, util.isBuffer(new Buffer(4)));
+  assert.equal(true, util.isBuffer(Buffer(4)));
+  assert.equal(true, util.isBuffer(new Buffer(4)));
+  assert.equal(true, util.isBuffer(new Buffer([1, 2, 3, 4])));
+  assert.equal(false, util.isBuffer({}));
+  assert.equal(false, util.isBuffer([]));
+  assert.equal(false, util.isBuffer(new Error()));
+  assert.equal(false, util.isRegExp(new Date()));
+  assert.equal(true, util.isBuffer(Object.create(Buffer.prototype)));
+});

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/node/debug.js

@@ -0,0 +1,86 @@
+// 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 assert = require('assert');
+var util = require('../../');
+
+if (process.argv[2] === 'child')
+  child();
+else
+  parent();
+
+function parent() {
+  test('foo,tud,bar', true);
+  test('foo,tud', true);
+  test('tud,bar', true);
+  test('tud', true);
+  test('foo,bar', false);
+  test('', false);
+}
+
+function test(environ, shouldWrite) {
+  var expectErr = '';
+  if (shouldWrite) {
+    expectErr = 'TUD %PID%: this { is: \'a\' } /debugging/\n' +
+                'TUD %PID%: number=1234 string=asdf obj={"foo":"bar"}\n';
+  }
+  var expectOut = 'ok\n';
+  var didTest = false;
+
+  var spawn = require('child_process').spawn;
+  var child = spawn(process.execPath, [__filename, 'child'], {
+    env: { NODE_DEBUG: environ }
+  });
+
+  expectErr = expectErr.split('%PID%').join(child.pid);
+
+  var err = '';
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', function(c) {
+    err += c;
+  });
+
+  var out = '';
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', function(c) {
+    out += c;
+  });
+
+  child.on('close', function(c) {
+    assert(!c);
+    assert.equal(err, expectErr);
+    assert.equal(out, expectOut);
+    didTest = true;
+    console.log('ok %j %j', environ, shouldWrite);
+  });
+
+  process.on('exit', function() {
+    assert(didTest);
+  });
+}
+
+
+function child() {
+  var debug = util.debuglog('tud');
+  debug('this', { is: 'a' }, /debugging/);
+  debug('number=%d string=%s obj=%j', 1234, 'asdf', { foo: 'bar' });
+  console.log('ok');
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/node/format.js

@@ -0,0 +1,77 @@
+// 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 assert = require('assert');
+var util = require('../../');
+
+assert.equal(util.format(), '');
+assert.equal(util.format(''), '');
+assert.equal(util.format([]), '[]');
+assert.equal(util.format({}), '{}');
+assert.equal(util.format(null), 'null');
+assert.equal(util.format(true), 'true');
+assert.equal(util.format(false), 'false');
+assert.equal(util.format('test'), 'test');
+
+// CHECKME this is for console.log() compatibility - but is it *right*?
+assert.equal(util.format('foo', 'bar', 'baz'), 'foo bar baz');
+
+assert.equal(util.format('%d', 42.0), '42');
+assert.equal(util.format('%d', 42), '42');
+assert.equal(util.format('%s', 42), '42');
+assert.equal(util.format('%j', 42), '42');
+
+assert.equal(util.format('%d', '42.0'), '42');
+assert.equal(util.format('%d', '42'), '42');
+assert.equal(util.format('%s', '42'), '42');
+assert.equal(util.format('%j', '42'), '"42"');
+
+assert.equal(util.format('%%s%s', 'foo'), '%sfoo');
+
+assert.equal(util.format('%s'), '%s');
+assert.equal(util.format('%s', undefined), 'undefined');
+assert.equal(util.format('%s', 'foo'), 'foo');
+assert.equal(util.format('%s:%s'), '%s:%s');
+assert.equal(util.format('%s:%s', undefined), 'undefined:%s');
+assert.equal(util.format('%s:%s', 'foo'), 'foo:%s');
+assert.equal(util.format('%s:%s', 'foo', 'bar'), 'foo:bar');
+assert.equal(util.format('%s:%s', 'foo', 'bar', 'baz'), 'foo:bar baz');
+assert.equal(util.format('%%%s%%', 'hi'), '%hi%');
+assert.equal(util.format('%%%s%%%%', 'hi'), '%hi%%');
+
+(function() {
+  var o = {};
+  o.o = o;
+  assert.equal(util.format('%j', o), '[Circular]');
+})();
+
+// Errors
+assert.equal(util.format(new Error('foo')), '[Error: foo]');
+function CustomError(msg) {
+  Error.call(this);
+  Object.defineProperty(this, 'message', { value: msg, enumerable: false });
+  Object.defineProperty(this, 'name', { value: 'CustomError', enumerable: false });
+}
+util.inherits(CustomError, Error);
+assert.equal(util.format(new CustomError('bar')), '[CustomError: bar]');

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/node/inspect.js

@@ -0,0 +1,195 @@
+// 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 assert = require('assert');
+var util = require('../../');
+
+// test the internal isDate implementation
+var Date2 = require('vm').runInNewContext('Date');
+var d = new Date2();
+var orig = util.inspect(d);
+Date2.prototype.foo = 'bar';
+var after = util.inspect(d);
+assert.equal(orig, after);
+
+// test for sparse array
+var a = ['foo', 'bar', 'baz'];
+assert.equal(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
+delete a[1];
+assert.equal(util.inspect(a), '[ \'foo\', , \'baz\' ]');
+assert.equal(util.inspect(a, true), '[ \'foo\', , \'baz\', [length]: 3 ]');
+assert.equal(util.inspect(new Array(5)), '[ , , , ,  ]');
+
+// test for property descriptors
+var getter = Object.create(null, {
+  a: {
+    get: function() { return 'aaa'; }
+  }
+});
+var setter = Object.create(null, {
+  b: {
+    set: function() {}
+  }
+});
+var getterAndSetter = Object.create(null, {
+  c: {
+    get: function() { return 'ccc'; },
+    set: function() {}
+  }
+});
+assert.equal(util.inspect(getter, true), '{ [a]: [Getter] }');
+assert.equal(util.inspect(setter, true), '{ [b]: [Setter] }');
+assert.equal(util.inspect(getterAndSetter, true), '{ [c]: [Getter/Setter] }');
+
+// exceptions should print the error message, not '{}'
+assert.equal(util.inspect(new Error()), '[Error]');
+assert.equal(util.inspect(new Error('FAIL')), '[Error: FAIL]');
+assert.equal(util.inspect(new TypeError('FAIL')), '[TypeError: FAIL]');
+assert.equal(util.inspect(new SyntaxError('FAIL')), '[SyntaxError: FAIL]');
+try {
+  undef();
+} catch (e) {
+  assert.equal(util.inspect(e), '[ReferenceError: undef is not defined]');
+}
+var ex = util.inspect(new Error('FAIL'), true);
+assert.ok(ex.indexOf('[Error: FAIL]') != -1);
+assert.ok(ex.indexOf('[stack]') != -1);
+assert.ok(ex.indexOf('[message]') != -1);
+
+// GH-1941
+// should not throw:
+assert.equal(util.inspect(Object.create(Date.prototype)), '{}');
+
+// GH-1944
+assert.doesNotThrow(function() {
+  var d = new Date();
+  d.toUTCString = null;
+  util.inspect(d);
+});
+
+assert.doesNotThrow(function() {
+  var r = /regexp/;
+  r.toString = null;
+  util.inspect(r);
+});
+
+// bug with user-supplied inspect function returns non-string
+assert.doesNotThrow(function() {
+  util.inspect([{
+    inspect: function() { return 123; }
+  }]);
+});
+
+// GH-2225
+var x = { inspect: util.inspect };
+assert.ok(util.inspect(x).indexOf('inspect') != -1);
+
+// util.inspect.styles and util.inspect.colors
+function test_color_style(style, input, implicit) {
+  var color_name = util.inspect.styles[style];
+  var color = ['', ''];
+  if(util.inspect.colors[color_name])
+    color = util.inspect.colors[color_name];
+
+  var without_color = util.inspect(input, false, 0, false);
+  var with_color = util.inspect(input, false, 0, true);
+  var expect = '\u001b[' + color[0] + 'm' + without_color +
+               '\u001b[' + color[1] + 'm';
+  assert.equal(with_color, expect, 'util.inspect color for style '+style);
+}
+
+test_color_style('special', function(){});
+test_color_style('number', 123.456);
+test_color_style('boolean', true);
+test_color_style('undefined', undefined);
+test_color_style('null', null);
+test_color_style('string', 'test string');
+test_color_style('date', new Date);
+test_color_style('regexp', /regexp/);
+
+// an object with "hasOwnProperty" overwritten should not throw
+assert.doesNotThrow(function() {
+  util.inspect({
+    hasOwnProperty: null
+  });
+});
+
+// new API, accepts an "options" object
+var subject = { foo: 'bar', hello: 31, a: { b: { c: { d: 0 } } } };
+Object.defineProperty(subject, 'hidden', { enumerable: false, value: null });
+
+assert(util.inspect(subject, { showHidden: false }).indexOf('hidden') === -1);
+assert(util.inspect(subject, { showHidden: true }).indexOf('hidden') !== -1);
+assert(util.inspect(subject, { colors: false }).indexOf('\u001b[32m') === -1);
+assert(util.inspect(subject, { colors: true }).indexOf('\u001b[32m') !== -1);
+assert(util.inspect(subject, { depth: 2 }).indexOf('c: [Object]') !== -1);
+assert(util.inspect(subject, { depth: 0 }).indexOf('a: [Object]') !== -1);
+assert(util.inspect(subject, { depth: null }).indexOf('{ d: 0 }') !== -1);
+
+// "customInspect" option can enable/disable calling inspect() on objects
+subject = { inspect: function() { return 123; } };
+
+assert(util.inspect(subject, { customInspect: true }).indexOf('123') !== -1);
+assert(util.inspect(subject, { customInspect: true }).indexOf('inspect') === -1);
+assert(util.inspect(subject, { customInspect: false }).indexOf('123') === -1);
+assert(util.inspect(subject, { customInspect: false }).indexOf('inspect') !== -1);
+
+// custom inspect() functions should be able to return other Objects
+subject.inspect = function() { return { foo: 'bar' }; };
+
+assert.equal(util.inspect(subject), '{ foo: \'bar\' }');
+
+subject.inspect = function(depth, opts) {
+  assert.strictEqual(opts.customInspectOptions, true);
+};
+
+util.inspect(subject, { customInspectOptions: true });
+
+// util.inspect with "colors" option should produce as many lines as without it
+function test_lines(input) {
+  var count_lines = function(str) {
+    return (str.match(/\n/g) || []).length;
+  }
+
+  var without_color = util.inspect(input);
+  var with_color = util.inspect(input, {colors: true});
+  assert.equal(count_lines(without_color), count_lines(with_color));
+}
+
+test_lines([1, 2, 3, 4, 5, 6, 7]);
+test_lines(function() {
+  var big_array = [];
+  for (var i = 0; i < 100; i++) {
+    big_array.push(i);
+  }
+  return big_array;
+}());
+test_lines({foo: 'bar', baz: 35, b: {a: 35}});
+test_lines({
+  foo: 'bar',
+  baz: 35,
+  b: {a: 35},
+  very_long_key: 'very_long_value',
+  even_longer_key: ['with even longer value in array']
+});

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/node/log.js

@@ -0,0 +1,58 @@
+// 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 assert = require('assert');
+var util = require('../../');
+
+assert.ok(process.stdout.writable);
+assert.ok(process.stderr.writable);
+
+var stdout_write = global.process.stdout.write;
+var strings = [];
+global.process.stdout.write = function(string) {
+  strings.push(string);
+};
+console._stderr = process.stdout;
+
+var tests = [
+  {input: 'foo', output: 'foo'},
+  {input: undefined, output: 'undefined'},
+  {input: null, output: 'null'},
+  {input: false, output: 'false'},
+  {input: 42, output: '42'},
+  {input: function(){}, output: '[Function]'},
+  {input: parseInt('not a number', 10), output: 'NaN'},
+  {input: {answer: 42}, output: '{ answer: 42 }'},
+  {input: [1,2,3], output: '[ 1, 2, 3 ]'}
+];
+
+// test util.log()
+tests.forEach(function(test) {
+  util.log(test.input);
+  var result = strings.shift().trim(),
+      re = (/[0-9]{1,2} [A-Z][a-z]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} - (.+)$/),
+      match = re.exec(result);
+  assert.ok(match);
+  assert.equal(match[1], test.output);
+});
+
+global.process.stdout.write = stdout_write;

goTorrentWebUI/node_modules/react-scripts/node_modules/util/test/node/util.js

@@ -0,0 +1,83 @@
+// 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 assert = require('assert');
+var context = require('vm').runInNewContext;
+
+var util = require('../../');
+
+// isArray
+assert.equal(true, util.isArray([]));
+assert.equal(true, util.isArray(Array()));
+assert.equal(true, util.isArray(new Array()));
+assert.equal(true, util.isArray(new Array(5)));
+assert.equal(true, util.isArray(new Array('with', 'some', 'entries')));
+assert.equal(true, util.isArray(context('Array')()));
+assert.equal(false, util.isArray({}));
+assert.equal(false, util.isArray({ push: function() {} }));
+assert.equal(false, util.isArray(/regexp/));
+assert.equal(false, util.isArray(new Error));
+assert.equal(false, util.isArray(Object.create(Array.prototype)));
+
+// isRegExp
+assert.equal(true, util.isRegExp(/regexp/));
+assert.equal(true, util.isRegExp(RegExp()));
+assert.equal(true, util.isRegExp(new RegExp()));
+assert.equal(true, util.isRegExp(context('RegExp')()));
+assert.equal(false, util.isRegExp({}));
+assert.equal(false, util.isRegExp([]));
+assert.equal(false, util.isRegExp(new Date()));
+assert.equal(false, util.isRegExp(Object.create(RegExp.prototype)));
+
+// isDate
+assert.equal(true, util.isDate(new Date()));
+assert.equal(true, util.isDate(new Date(0)));
+assert.equal(true, util.isDate(new (context('Date'))));
+assert.equal(false, util.isDate(Date()));
+assert.equal(false, util.isDate({}));
+assert.equal(false, util.isDate([]));
+assert.equal(false, util.isDate(new Error));
+assert.equal(false, util.isDate(Object.create(Date.prototype)));
+
+// isError
+assert.equal(true, util.isError(new Error));
+assert.equal(true, util.isError(new TypeError));
+assert.equal(true, util.isError(new SyntaxError));
+assert.equal(true, util.isError(new (context('Error'))));
+assert.equal(true, util.isError(new (context('TypeError'))));
+assert.equal(true, util.isError(new (context('SyntaxError'))));
+assert.equal(false, util.isError({}));
+assert.equal(false, util.isError({ name: 'Error', message: '' }));
+assert.equal(false, util.isError([]));
+assert.equal(true, util.isError(Object.create(Error.prototype)));
+
+// isObject
+assert.ok(util.isObject({}) === true);
+
+// _extend
+assert.deepEqual(util._extend({a:1}),             {a:1});
+assert.deepEqual(util._extend({a:1}, []),         {a:1});
+assert.deepEqual(util._extend({a:1}, null),       {a:1});
+assert.deepEqual(util._extend({a:1}, true),       {a:1});
+assert.deepEqual(util._extend({a:1}, false),      {a:1});
+assert.deepEqual(util._extend({a:1}, {b:2}),      {a:1, b:2});
+assert.deepEqual(util._extend({a:1, b:2}, {b:3}), {a:1, b:3});

goTorrentWebUI/node_modules/react-scripts/node_modules/util/util.js

@@ -0,0 +1,586 @@
+// 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 formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(global.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}