@contrast/agent 3.11.10

package/node_modules/object-hash/test/replacer.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var assert = require('assert');
+var stream = require('stream');
+var hash = require('../index');
+
+describe('replacer option', function() {
+  it('should emit information about an object to a stream', function() {
+    var strm = new stream.PassThrough();
+    
+    var replacer = function(value) {
+      try {
+        return JSON.stringify(value);
+      } catch (e) {
+        return value;
+      }
+    };
+    
+    var obj = {foo: 'bar'};
+    hash.writeToStream(obj, {replacer: replacer}, strm);
+    var result = strm.read().toString();
+    assert.strictEqual(typeof result, 'string');
+    assert.notStrictEqual(result.indexOf(JSON.stringify(obj)), -1);
+  });
+
+  it('should not reach property values when excludeValues = true', function() {
+    var strm = new stream.PassThrough();
+    
+    var replacer = function(k) {
+      assert.notStrictEqual(k, 'bar');
+      return k;
+    };
+    
+    hash.writeToStream({foo: 'bar'}, {excludeValues: true}, strm);
+  });
+});

package/node_modules/object-hash/test/types.js

@@ -0,0 +1,174 @@
+'use strict';
+
+var assert = require('assert');
+var crypto = require('crypto');
+var hash = require('../index');
+var validSha1 = /^[0-9a-f]{40}$/i;
+
+describe('hash()ing different types', function() {
+  it('hashes non-object types', function() {
+    var func = function(a){ return a + 1; };
+    assert.ok(validSha1.test(hash('Shazbot!')), 'hash string');
+    assert.ok(validSha1.test(hash(42)), 'hash number');
+    assert.ok(validSha1.test(hash(NaN)), 'hash bool');
+    assert.ok(validSha1.test(hash(true)), 'hash bool');
+    assert.ok(validSha1.test(hash(func)), 'hash function');
+  });
+
+  it('hashes special object types', function() {
+    var dt = new Date();
+    dt.setDate(dt.getDate() + 1);
+
+    assert.ok(validSha1.test(hash([1,2,3,4])), 'hash array');
+    assert.notEqual(hash([1,2,3,4]), hash([4,3,2,1]), 'different arrays not equal');
+    assert.ok(validSha1.test(hash(new Date())), 'hash date');
+    assert.notEqual(hash(new Date()), hash(dt), 'different dates not equal');
+    assert.ok(validSha1.test(hash(null)), 'hash Null');
+    assert.ok(validSha1.test(hash(Number.NaN)), 'hash NaN');
+    assert.ok(validSha1.test(hash({ foo: undefined })), 'hash Undefined value');
+    assert.ok(validSha1.test(hash(new RegExp())), 'hash regex');
+    assert.ok(validSha1.test(hash(new Error())), 'hash error');
+  });
+
+  it('hashes node.js-internal object types', function() {
+    if (typeof process !== 'undefined') {
+      assert.ok(validSha1.test(hash(process)), 'hash process');
+    }
+    
+    var timer = setTimeout(function() {}, 0);
+    assert.ok(validSha1.test(hash(timer)), 'hash timer');
+  });
+
+  if (typeof Symbol !== 'undefined') {
+    it('hashes Symbols', function() {
+      assert.ok(validSha1.test(hash(Symbol('Banana'))), 'hash error');
+    });
+  }
+
+  if (typeof Buffer !== 'undefined') {
+    it("Buffers can be hashed", function() {
+      assert.ok(validSha1.test(hash(new Buffer('Banana'))), 'hashes Buffers');
+    });
+  }
+
+  if (typeof Uint8Array !== 'undefined') {
+    it("Typed arrays can be hashed", function() {
+      
+      assert.ok(validSha1.test(hash(new Uint8Array([1,2,3,4]))), 'hashes Uint8Array');
+      assert.ok(validSha1.test(hash(new  Int8Array([1,2,3,4]))), 'hashes  Int8Array');
+      assert.ok(validSha1.test(hash(new Uint16Array([1,2,3,4]))), 'hashes Uint16Array');
+      assert.ok(validSha1.test(hash(new  Int16Array([1,2,3,4]))), 'hashes  Int16Array');
+      assert.ok(validSha1.test(hash(new Uint32Array([1,2,3,4]))), 'hashes Uint32Array');
+      assert.ok(validSha1.test(hash(new  Int32Array([1,2,3,4]))), 'hashes  Int32Array');
+      assert.ok(validSha1.test(hash(new Float32Array([1,2,3,4]))), 'hashes Float32Array');
+      if (typeof Float64Array !== 'undefined')
+      assert.ok(validSha1.test(hash(new Float64Array([1,2,3,4]))), 'hashes Float64Array');
+      if (typeof Uint8ClampedArray !== 'undefined')
+      assert.ok(validSha1.test(hash(new Uint8ClampedArray([1,2,3,4]))), 'hashes Uint8ClampedArray');
+      assert.ok(validSha1.test(hash(new Uint8Array([1,2,3,4]).buffer)), 'hashes ArrayBuffer');
+    });
+  }
+
+  if (typeof Map !== 'undefined') {
+    it("Maps can be hashed", function() {
+      var map = new Map([['a',1],['b',2]]);
+      assert.ok(validSha1.test(hash(map)), 'hashes Maps');
+    });
+  }
+
+  if (typeof WeakMap !== 'undefined') {
+    it("WeakMaps can’t be hashed", function() {
+      var map = new WeakMap([[{foo: 'bar'},1]]);
+      assert.throws(function() {
+        validSha1.test(hash(map))
+      }, 'does not hash WeakMaps');
+    });
+  }
+
+  if (typeof Set !== 'undefined') {
+    it("Sets can be hashed", function() {
+      var set = new Set(['you', 'du', 'tu', 'あなた', '您']);
+      assert.ok(validSha1.test(hash(set)), 'hashes Sets');
+    });
+  }
+
+  if (typeof WeakSet !== 'undefined') {
+    it("WeakSets can’t be hashed", function() {
+      var obj = {foo: 'bar'};
+      var set = new WeakSet([obj]);
+      assert.throws(function() {
+        validSha1.test(hash(set))
+      }, 'does not hash WeakSets');
+    });
+  }
+
+  it("Builtin types themselves can be hashed", function() {
+    var hashcount = {};
+    var types = [Object, Date, Number, String, Function, RegExp,
+      Error, 0, null, NaN];
+    if (typeof WeakSet !== 'undefined') types.push(WeakSet);
+    if (typeof Set !== 'undefined') types.push(Set);
+    if (typeof WeakMap !== 'undefined') types.push(WeakMap);
+    if (typeof Map !== 'undefined') types.push(Map);
+    if (typeof Symbol !== 'undefined') types.push(Symbol);
+    if (typeof Uint8Array !== 'undefined') types.push(Uint8Array);
+
+    // Hash each type
+    for (var idx in types) {
+      var h = hash(types[idx]);
+      assert.ok(validSha1.test(h));
+      hashcount[h] = (hashcount[h] || 0) + 1;
+    }
+
+    // Check for collisions
+    var no = 0;
+    for (var h in hashcount) {
+      assert.equal(hashcount[h], 1);
+      no++;
+    }
+
+    // Self check; did we really hash all the types?
+    assert.equal(no, types.length);
+  });
+  
+  it("Builtin types might result in identical hashes with respectFunctionNames = false", function() {
+    var hashcount = {};
+    var types = [Object, Date, Number, String, Function, RegExp,
+      Error, 0, null, NaN];
+    if (typeof WeakSet !== 'undefined') types.push(WeakSet);
+    if (typeof Set !== 'undefined') types.push(Set);
+    if (typeof WeakMap !== 'undefined') types.push(WeakMap);
+    if (typeof Map !== 'undefined') types.push(Map);
+    if (typeof Symbol !== 'undefined') types.push(Symbol);
+    if (typeof Uint8Array !== 'undefined') types.push(Uint8Array);
+
+    // Hash each type
+    for (var idx in types) {
+      var h = hash(types[idx], { respectFunctionNames: false });
+      assert.ok(validSha1.test(h));
+      hashcount[h] = (hashcount[h] || 0) + 1;
+    }
+
+    // Check for collisions
+    var no = 0;
+    for (var h in hashcount) {
+      assert.ok(hashcount[h] >= 1);
+      no += hashcount[h];
+    }
+
+    // Self check; did we really hash all the types?
+    assert.equal(no, types.length);
+  });
+  
+  it("Functions with identical bodies and different names result in identical hashes with respectFunctionNames = false", function() {
+    var fn1 = function a() {};
+    var fn2 = function b() {};
+    var toStringDummy = function() { return '...'; };
+    fn1.toString = toStringDummy;
+    fn2.toString = toStringDummy;
+    
+    var h1 = hash(fn1, { respectFunctionNames: false });
+    var h2 = hash(fn2, { respectFunctionNames: false });
+    assert.strictEqual(h1, h2);
+  });
+});

package/node_modules/object-hash/test/writeToStream.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var assert = require('assert');
+var stream = require('stream');
+var hash = require('../index');
+
+describe('writeToStream', function() {
+  it('should emit information about an object to a stream', function() {
+    var strm = new stream.PassThrough();
+    
+    hash.writeToStream({foo: 'bar'}, strm);
+    var result = strm.read().toString();
+    assert.strictEqual(typeof result, 'string');
+    assert.notStrictEqual(result.indexOf('foo'), -1);
+    assert.notStrictEqual(result.indexOf('bar'), -1);
+  });
+
+  it('should leave out keys when excludeValues = true', function() {
+    var strm = new stream.PassThrough();
+    
+    hash.writeToStream({foo: 'bar'}, {excludeValues: true}, strm);
+    var result = strm.read().toString();
+    assert.strictEqual(typeof result, 'string');
+    assert.notStrictEqual(result.indexOf('foo'), -1);
+    assert.   strictEqual(result.indexOf('bar'), -1);
+  });
+});

package/node_modules/one-time/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Unshift.io, Arnout Kazemier,  the 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.
+

package/node_modules/one-time/README.md

@@ -0,0 +1,88 @@
+# one-time
+
+Call the supplied function exactly one time. This prevents double callback
+execution. This module can be used on both Node.js, React-Native, or browsers
+using Browserify. No magical ES5/6 methods used unlike the `once` module does
+(except for the async version).
+
+## Installation
+
+This module is published to the public npm registry and can be installed
+by running:
+
+```sh
+npm install --save one-time
+```
+
+## Usage (normal)
+
+Simply supply the function with the function that should only be called one
+time:
+
+```js
+var one = require('one-time');
+
+function load(file, fn) {
+  fn = one(fn);
+
+  eventemitter.once('load', fn);
+  eventemitter.once('error', fn);
+
+  // do stuff
+  eventemitter.emit('error', new Error('Failed to load, but still finished'));
+  eventemitter.emit('load');
+}
+
+function example(fn) {
+  fn = one(fn);
+
+  fn();
+  fn('also receives all arguments');
+  fn('it returns the same value') === 'bar';
+  fn('never');
+  fn('gonna');
+  fn('give');
+  fn('you');
+  fn('up');
+}
+
+example(function () {
+  return 'bar'
+});
+```
+
+## Usage (async)
+
+The same pattern is available for **async** functions as well, for that you
+should import that `one-time/async` version instead. This one is optimized
+for **async** and **await** support. It following exactly the same as the
+normal version but assumes it's an `async function () {}` that it's wrapping
+instead of a regular function, and it will return an `async function() {}`
+instead of a regular function.
+
+```js
+import one from 'one-time/async';
+
+const fn = one(async function () {
+  return await example();
+});
+
+await fn();
+await fn();
+await fn();
+```
+
+### Why not `once`?
+
+The main reason is that `once` cannot be used in a browser environment unless
+it's ES5 compatible. For a module as simple as this I find that unacceptable. In
+addition to that it super heavy on the dependency side. So it's totally not
+suitable to be used in client side applications.
+
+In addition to that we make sure that your code stays easy to debug as returned
+functions are named in the same way as your supplied functions. Making heap
+inspection and stack traces easier to understand.
+
+## License
+
+[MIT](LICENSE)

package/node_modules/one-time/async.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var name = require('fn.name');
+
+/**
+ * Wrap callbacks to prevent double execution.
+ *
+ * @param {Function} fn Function that should only be called once.
+ * @returns {Function} A async wrapped callback which prevents multiple executions.
+ * @public
+ */
+module.exports = function one(fn) {
+  var called = 0
+    , value;
+
+  /**
+   * The function that prevents double execution.
+   *
+   * @async
+   * @public
+   */
+  async function onetime() {
+    if (called) return value;
+
+    called = 1;
+    value = await fn.apply(this, arguments);
+    fn = null;
+
+    return value;
+  }
+
+  //
+  // To make debugging more easy we want to use the name of the supplied
+  // function. So when you look at the functions that are assigned to event
+  // listeners you don't see a load of `onetime` functions but actually the
+  // names of the functions that this module will call.
+  //
+  // NOTE: We cannot override the `name` property, as that is `readOnly`
+  // property, so displayName will have to do.
+  //
+  onetime.displayName = name(fn);
+  return onetime;
+};

package/node_modules/one-time/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var name = require('fn.name');
+
+/**
+ * Wrap callbacks to prevent double execution.
+ *
+ * @param {Function} fn Function that should only be called once.
+ * @returns {Function} A wrapped callback which prevents multiple executions.
+ * @public
+ */
+module.exports = function one(fn) {
+  var called = 0
+    , value;
+
+  /**
+   * The function that prevents double execution.
+   *
+   * @private
+   */
+  function onetime() {
+    if (called) return value;
+
+    called = 1;
+    value = fn.apply(this, arguments);
+    fn = null;
+
+    return value;
+  }
+
+  //
+  // To make debugging more easy we want to use the name of the supplied
+  // function. So when you look at the functions that are assigned to event
+  // listeners you don't see a load of `onetime` functions but actually the
+  // names of the functions that this module will call.
+  //
+  // NOTE: We cannot override the `name` property, as that is `readOnly`
+  // property, so displayName will have to do.
+  //
+  onetime.displayName = name(fn);
+  return onetime;
+};

package/node_modules/one-time/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "one-time",
+  "version": "1.0.0",
+  "description": "Run the supplied function exactly one time (once)",
+  "main": "index.js",
+  "scripts": {
+    "test:runner": "mocha test.js",
+    "test:watch": "npm run test:runner -- --watch",
+    "test": "nyc --reporter=text --reporter=json-summary npm run test:runner"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/3rd-Eden/one-time.git"
+  },
+  "keywords": [
+    "once",
+    "function",
+    "single",
+    "one",
+    "one-time",
+    "execution",
+    "nope"
+  ],
+  "author": "Arnout Kazemier",
+  "license": "MIT",
+  "devDependencies": {
+    "assume": "^2.2.0",
+    "mocha": "^6.1.4",
+    "nyc": "^14.1.0"
+  },
+  "dependencies": {
+    "fn.name": "1.x.x"
+  }
+
+,"_resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz"
+,"_integrity": "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g=="
+,"_from": "one-time@1.0.0"
+}

package/node_modules/process-nextick-args/index.js

@@ -0,0 +1,45 @@
+'use strict';
+
+if (typeof process === 'undefined' ||
+    !process.version ||
+    process.version.indexOf('v0.') === 0 ||
+    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+  module.exports = { nextTick: nextTick };
+} else {
+  module.exports = process
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('"callback" argument must be a function');
+  }
+  var len = arguments.length;
+  var args, i;
+  switch (len) {
+  case 0:
+  case 1:
+    return process.nextTick(fn);
+  case 2:
+    return process.nextTick(function afterTickOne() {
+      fn.call(null, arg1);
+    });
+  case 3:
+    return process.nextTick(function afterTickTwo() {
+      fn.call(null, arg1, arg2);
+    });
+  case 4:
+    return process.nextTick(function afterTickThree() {
+      fn.call(null, arg1, arg2, arg3);
+    });
+  default:
+    args = new Array(len - 1);
+    i = 0;
+    while (i < args.length) {
+      args[i++] = arguments[i];
+    }
+    return process.nextTick(function afterTick() {
+      fn.apply(null, args);
+    });
+  }
+}
+

package/node_modules/process-nextick-args/license.md

@@ -0,0 +1,19 @@
+# Copyright (c) 2015 Calvin Metcalf
+
+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.**

package/node_modules/process-nextick-args/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "process-nextick-args",
+  "version": "2.0.1",
+  "description": "process.nextTick but always with args",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/calvinmetcalf/process-nextick-args.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/calvinmetcalf/process-nextick-args/issues"
+  },
+  "homepage": "https://github.com/calvinmetcalf/process-nextick-args",
+  "devDependencies": {
+    "tap": "~0.2.6"
+  }
+
+,"_resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
+,"_integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="
+,"_from": "process-nextick-args@2.0.1"
+}

package/node_modules/process-nextick-args/readme.md

@@ -0,0 +1,18 @@
+process-nextick-args
+=====
+
+[![Build Status](https://travis-ci.org/calvinmetcalf/process-nextick-args.svg?branch=master)](https://travis-ci.org/calvinmetcalf/process-nextick-args)
+
+```bash
+npm install --save process-nextick-args
+```
+
+Always be able to pass arguments to process.nextTick, no matter the platform
+
+```js
+var pna = require('process-nextick-args');
+
+pna.nextTick(function (a, b, c) {
+  console.log(a, b, c);
+}, 'step', 3,  'profit');
+```

package/node_modules/readable-stream/.travis.yml

@@ -0,0 +1,34 @@
+sudo: false
+language: node_js
+before_install:
+  - (test $NPM_LEGACY && npm install -g npm@2 && npm install -g npm@3) || true
+notifications:
+  email: false
+matrix:
+  fast_finish: true
+  include:
+  - node_js: '0.8'
+    env: NPM_LEGACY=true
+  - node_js: '0.10'
+    env: NPM_LEGACY=true
+  - node_js: '0.11'
+    env: NPM_LEGACY=true
+  - node_js: '0.12'
+    env: NPM_LEGACY=true
+  - node_js: 1
+    env: NPM_LEGACY=true
+  - node_js: 2
+    env: NPM_LEGACY=true
+  - node_js: 3
+    env: NPM_LEGACY=true
+  - node_js: 4
+  - node_js: 5
+  - node_js: 6
+  - node_js: 7
+  - node_js: 8
+  - node_js: 9
+script: "npm run test"
+env:
+  global:
+  - secure: rE2Vvo7vnjabYNULNyLFxOyt98BoJexDqsiOnfiD6kLYYsiQGfr/sbZkPMOFm9qfQG7pjqx+zZWZjGSswhTt+626C0t/njXqug7Yps4c3dFblzGfreQHp7wNX5TFsvrxd6dAowVasMp61sJcRnB2w8cUzoe3RAYUDHyiHktwqMc=
+  - secure: g9YINaKAdMatsJ28G9jCGbSaguXCyxSTy+pBO6Ch0Cf57ZLOTka3HqDj8p3nV28LUIHZ3ut5WO43CeYKwt4AUtLpBS3a0dndHdY6D83uY6b2qh5hXlrcbeQTq2cvw2y95F7hm4D1kwrgZ7ViqaKggRcEupAL69YbJnxeUDKWEdI=

package/node_modules/readable-stream/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+  have the right to submit it under the open source license
+  indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+  of my knowledge, is covered under an appropriate open source
+  license and I have the right under that license to submit that
+  work with modifications, whether created in whole or in part
+  by me, under the same open source license (unless I am
+  permitted to submit under a different license), as indicated
+  in the file; or
+
+* (c) The contribution was provided directly to me by some other
+  person who certified (a), (b) or (c) and I have not modified
+  it.
+
+* (d) I understand and agree that this project and the contribution
+  are public and that a record of the contribution (including all
+  personal information I submit with it, including my sign-off) is
+  maintained indefinitely and may be redistributed consistent with
+  this project or the open source license(s) involved.
+
+## Moderation Policy
+
+The [Node.js Moderation Policy] applies to this WG.
+
+## Code of Conduct
+
+The [Node.js Code of Conduct][] applies to this WG.
+
+[Node.js Code of Conduct]:
+https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
+[Node.js Moderation Policy]:
+https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md