@contrast/agent 4.32.10 → 4.32.12

package/node_modules/object-hash/gulpfile.js

@@ -1,97 +0,0 @@
-'use strict';
-
-var gulp = require('gulp');
-var jshint = require('gulp-jshint');
-var exec = require('gulp-exec');
-var stylish = require('jshint-stylish');
-var browserify = require('gulp-browserify');
-var uglify = require('gulp-uglify');
-var rename = require('gulp-rename');
-var karma = require('karma');
-var coveralls = require('gulp-coveralls');
-var istanbul = require('gulp-istanbul');
-var mocha = require('gulp-mocha');
-
-var paths = {
-  index: './index.js',
-  tests: './test/**/*.js'
-};
-
-function preTest(src) {
-  return gulp.src(src)
-    .pipe(istanbul())
-    .pipe(istanbul.hookRequire());
-}
-
-function test(src){
-  return gulp.src(src)
-    .pipe(mocha())
-    .pipe(istanbul.writeReports());
-}
-
-function testKarma(done){
-  new karma.Server({
-    configFile: __dirname + '/karma.conf.js',
-    singleRun: true
-  }, done).start();
-}
-
-function lint(src){
-  return gulp.src(src)
-    .pipe(jshint('.jshintrc'))
-    .pipe(jshint.reporter(stylish));
-}
-
-gulp.task('dist', function(){
-  gulp.src([paths.index])
-    .pipe(browserify({
-      insertGlobals : true,
-      debug: true,
-      standalone: 'objectHash'
-    }))
-    .pipe(rename('object_hash.js'))
-    .pipe(uglify({outSourceMap: true}))
-    .pipe(gulp.dest('./dist'));
-    // tests
-  gulp.src([paths.tests])
-    .pipe(browserify())
-    .pipe(rename('object_hash_test.js'))
-    .pipe(gulp.dest('./dist'));
-});
-
-gulp.task('pre-test', function() {
-  preTest([paths.index]);
-});
-
-gulp.task('test', ['pre-test'], function() {
-  test([paths.tests]);
-});
-
-gulp.task('karma', function() {
-  testKarma();
-});
-
-gulp.task('coveralls', function() {
-  gulp.src('coverage/**/lcov.info')
-    .pipe(coveralls());
-});
-
-gulp.task('lint', function () {
-  return lint([paths.index]);
-});
-
-gulp.task('watch', function () {
-
-  // watch and lint any files that are added or changed
-  gulp.watch([paths.index, paths.tests], function(event){
-    if(event.type !== 'deleted') {
-      lint([event.path]);
-    }
-  });
-
-  // run the tests when something changes
-  gulp.watch([paths.index, paths.tests], ['test', 'karma']);
-
-});
-
-gulp.task('default', ['watch']);

package/node_modules/object-hash/karma.conf.js

@@ -1,69 +0,0 @@
-// Karma configuration
-// Generated on Thu Dec 10 2015 03:01:27 GMT+0100 (CET)
-
-module.exports = function(config) {
-  config.set({
-
-    // base path that will be used to resolve all patterns (eg. files, exclude)
-    basePath: '',
-
-
-    // frameworks to use
-    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
-    frameworks: ['mocha'],
-
-
-    // list of files / patterns to load in the browser
-    files: [
-      'dist/*.js'
-    ],
-
-
-    // list of files to exclude
-    exclude: [
-    ],
-
-
-    // preprocess matching files before serving them to the browser
-    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
-    preprocessors: {
-    },
-
-
-    // test results reporter to use
-    // possible values: 'dots', 'progress'
-    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
-    reporters: ['progress'],
-
-
-    // web server port
-    port: 9876,
-
-
-    // enable / disable colors in the output (reporters and logs)
-    colors: true,
-
-
-    // level of logging
-    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
-    logLevel: config.LOG_INFO,
-
-
-    // enable / disable watching file and executing tests whenever any file changes
-    autoWatch: true,
-
-
-    // start these browsers
-    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
-    browsers: ['PhantomJS', 'Firefox'],
-
-
-    // Continuous Integration mode
-    // if true, Karma captures browsers, runs the tests and exits
-    singleRun: false,
-
-    // Concurrency level
-    // how many browser should be started simultanous
-    concurrency: Infinity
-  })
-}

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

@@ -1,41 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var hash = require('../index');
-
-if (typeof Blob !== 'undefined') {
-describe('hash()ing Blob objects', function() {
-  var blob;
-  before('create blob', function() {
-    try {
-      blob = new Blob(['ABC']);
-    } catch(e) {
-      // https://github.com/ariya/phantomjs/issues/11013
-      if (!e.message.match(/'\[object BlobConstructor\]' is not a constructor/)) {
-        throw e;
-      }
-      
-      var builder = new WebKitBlobBuilder();
-      builder.append('ABC');
-      blob = builder.getBlob();
-    }
-  });
-
-  it('should throw when trying to hash a blob', function() {
-    assert.throws(function() {
-      hash(blob);
-    }, /not supported/);
-    
-    assert.throws(function() {
-      hash({abcdef: blob});
-    }, /not supported/);
-  });
-
-  it('should not throw when trying to hash a blob with ignoreUnknown', function() {
-    var opt = {ignoreUnknown: true};
-    
-    assert.ok(validSha1.test(hash(blob, opt)), 'ignore Blob');
-    assert.ok(validSha1.test(hash({abcdef: blob}, opt)), 'ignore Blob');
-  });
-});
-}

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

@@ -1,290 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var crypto = require('crypto');
-var hash = require('../index');
-var validSha1 = /^[0-9a-f]{40}$/i;
-
-describe('hash', function() {
-  it('throws when nothing to hash', function () {
-    assert.throws(hash, 'no arguments');
-    assert.throws(function() {
-      hash(undefined, {algorithm: 'md5'});
-    }, 'undefined');
-  });
-
-  it('throws when passed an invalid options', function() {
-    assert.throws(function() {
-      hash({foo: 'bar'}, {algorithm: 'shalala'});
-    }, 'bad algorithm');
-    assert.throws(function() {
-      hash({foo: 'bar'}, {encoding: 'base16'});
-    }, 'bad encoding');
-  });
-
-  it('hashes a simple object', function() {
-    assert.ok(validSha1.test(hash({foo: 'bar', bar: 'baz'})), 'hash object');
-  });
-
-  if (typeof Buffer !== 'undefined') {
-    it('can return buffers', function() {
-      assert.ok(Buffer.isBuffer(hash({foo: 'bar', bar: 'baz'}, {encoding: 'buffer'})), 'hash object');
-    });
-  }
-
-  it('hashes identical objects with different key ordering', function() {
-    var hash1 = hash({foo: 'bar', bar: 'baz'});
-    var hash2 = hash({bar: 'baz', foo: 'bar'});
-    var hash3 = hash({bar: 'foo', foo: 'baz'});
-    assert.equal(hash1, hash2, 'hashes are equal');
-    assert.notEqual(hash1, hash3, 'different objects not equal');
-  });
-
-  it('respects object key ordering when unorderedObjects = false', function() {
-    var hash1 = hash({foo: 'bar', bar: 'baz'}, { unorderedObjects: false });
-    var hash2 = hash({bar: 'baz', foo: 'bar'}, { unorderedObjects: false });
-    assert.notEqual(hash1, hash2, 'hashes are not equal');
-  });
-
-  it('hashes only object keys when excludeValues option is set', function() {
-    var hash1 = hash({foo: false, bar: 'OK'}, { excludeValues: true });
-    var hash2 = hash({foo: true, bar: 'NO'}, { excludeValues: true });
-    var hash3 = hash({foo: true, bar: 'OK', baz: false}, { excludeValues: true });
-    assert.equal(hash1, hash2, 'values not in hash digest');
-    assert.notEqual(hash1, hash3, 'different keys not equal');
-  });
-
-  it('array values are hashed', function() {
-    var hash1 = hash({foo: ['bar', 'baz'], bax: true });
-    var hash2 = hash({foo: ['baz', 'bar'], bax: true });
-    assert.notEqual(hash1, hash2, 'different array orders are unique');
-  });
-
-  it('nested object values are hashed', function() {
-    var hash1 = hash({foo: {bar: true, bax: 1}});
-    var hash2 = hash({foo: {bar: true, bax: 1}});
-    var hash3 = hash({foo: {bar: false, bax: 1}});
-    assert.equal(hash1, hash2, 'hashes are equal');
-    assert.notEqual(hash1, hash3, 'different objects not equal');
-  });
-
-  it('sugar methods should be equivalent', function() {
-    var obj = {foo: 'bar', baz: true};
-    assert.equal(hash.keys(obj), hash(obj, {excludeValues: true}), 'keys');
-    assert.equal(hash.sha1(obj), hash(obj, {algorithm: 'sha1'}), 'sha1');
-    assert.equal(hash.MD5(obj), hash(obj, {algorithm: 'md5'}), 'md5');
-    assert.equal(hash.keysMD5(obj),
-      hash(obj, {algorithm: 'md5', excludeValues: true}), 'keys md5');
-  });
-
-  it('array of nested object values are hashed', function() {
-    var hash1 = hash({foo: [ {bar: true, bax: 1}, {bar: false, bax: 2} ] });
-    var hash2 = hash({foo: [ {bar: true, bax: 1}, {bar: false, bax: 2} ] });
-    var hash3 = hash({foo: [ {bar: false, bax: 2} ] });
-    assert.equal(hash1, hash2, 'hashes are equal');
-    assert.notEqual(hash1, hash3, 'different objects not equal');
-  });
-
-  it("recursive objects don't blow up stack", function() {
-    var hash1 = {foo: 'bar'};
-    hash1.recursive = hash1;
-    assert.doesNotThrow(function() {hash(hash1);}, /Maximum call stack size exceeded/, 'Should not throw an stack size exceeded exception');
-  });
-
-  it("recursive arrays don't blow up stack", function() {
-    var hash1 = ['foo', 'bar'];
-    hash1.push(hash1);
-    assert.doesNotThrow(function() {hash(hash1);}, /Maximum call stack size exceeded/, 'Should not throw an stack size exceeded exception');
-  });
-
-  it("recursive arrays don't blow up stack with unorderedArrays", function() {
-    var hash1 = ['foo', 'bar'];
-    hash1.push(hash1);
-    assert.doesNotThrow(function() {hash(hash1, {unorderedArrays: true});}, /Maximum call stack size exceeded/, 'Should not throw an stack size exceeded exception');
-  });
-
-  it("recursive handling tracks identity", function() {
-    var hash1 = {k1: {k: 'v'}, k2: {k: 'k2'}};
-    hash1.k1.r1 = hash1.k1;
-    hash1.k2.r2 = hash1.k2;
-    var hash2 = {k1: {k: 'v'}, k2: {k: 'k2'}};
-    hash2.k1.r1 = hash2.k2;
-    hash2.k2.r2 = hash2.k1;
-    assert.notEqual(hash(hash1), hash(hash2), "order of recursive objects should matter");
-  });
-
-  it("object types are hashed", function() {
-    var hash1 = hash({foo: 'bar'});
-    var hash2 = hash(['foo', 'bar']);
-    assert.notEqual(hash1, hash2, "arrays and objects should not produce identical hashes");
-  });
-
-  it("utf8 strings are hashed correctly", function() {
-    var hash1 = hash('\u03c3'); // cf 83 in utf8
-    var hash2 = hash('\u01c3'); // c7 83 in utf8
-    assert.notEqual(hash1, hash2, "different strings with similar utf8 encodings should produce different hashes");
-  });
-
-  it("strings passed as new String are hashed correctly", function() {
-    var hash1 = hash(new String('foo'));
-    assert.equal(hash1, '7cd3edacc4c9dd43908177508c112608a398bb9a');
-    var hash2 = hash({foo: new String('bar')});
-    assert.equal(hash2, 'a75c05bdca7d704bdfcd761913e5a4e4636e956b');
-  });
-
-  it("various hashes in crypto.getHashes() should be supported", function() {
-    var hashes = ['sha1', 'md5'];
-
-    if (crypto.getHashes) {
-      // take all hashes from crypto.getHashes() starting with MD or SHA
-      hashes = crypto.getHashes().filter(RegExp.prototype.test.bind(/^(md|sha)/i));
-    }
-
-    var obj = {randomText: 'bananas'};
-
-    for (var i = 0; i < hashes.length; i++) {
-      assert.ok(hash(obj, {algorithm: hashes[i]}), 'Algorithm ' + hashes[i] + ' should be supported');
-    }
-  });
-
-  it("null and 'Null' string produce different hashes", function() {
-    var hash1 = hash({foo: null});
-    var hash2 = hash({foo: 'Null'});
-    assert.notEqual(hash1, hash2, "null and 'Null' should not produce identical hashes");
-  });
-
-  it('Distinguish functions based on their properties', function() {
-
-    var a, b, c, d;
-    function Foo() {}
-    a = hash(Foo);
-
-    Foo.foo = 22;
-    b = hash(Foo);
-
-    Foo.bar = "42";
-    c = hash(Foo);
-
-    Foo.foo = "22";
-    d = hash(Foo);
-
-    assert.notEqual(a,b, 'adding a property changes the hash');
-    assert.notEqual(b,c, 'adding another property changes the hash');
-    assert.notEqual(c,d, 'changing a property changes the hash');
-  });
-
-  it('respectFunctionProperties = false', function() {
-
-    var a, b;
-    function Foo() {}
-    a = hash(Foo, {respectFunctionProperties: false});
-
-    Foo.foo = 22;
-    b = hash(Foo, {respectFunctionProperties: false});
-
-    assert.equal(a,b, 'function properties are ignored');
-  });
-
-  it('Distinguish functions based on prototype properties', function() {
-
-    var a, b, c, d;
-    function Foo() {}
-    a = hash(Foo);
-
-    Foo.prototype.foo = 22;
-    b = hash(Foo);
-
-    Foo.prototype.bar = "42";
-    c = hash(Foo);
-
-    Foo.prototype.foo = "22";
-    d = hash(Foo);
-
-    assert.notEqual(a,b, 'adding a property to the prototype changes the hash');
-    assert.notEqual(b,c, 'adding another property to the prototype changes the hash');
-    assert.notEqual(c,d, 'changing a property in the prototype changes the hash');
-  });
-
-  it('Distinguish objects based on their type', function() {
-
-    function Foo() {}
-    function Bar() {}
-
-    var f = new Foo(), b = new Bar();
-
-    assert.notEqual(hash(Foo), hash(Bar), 'Functions with different names should produce a different Hash.');
-    assert.notEqual(hash(f), hash(b), 'Objects with different constructor should have a different Hash.');
-  });
-
-  it('respectType = false', function() {
-    var opt = { respectType: false };
-
-
-    function Foo() {}
-    function Bar() {}
-
-    var f = new Foo(), b = new Bar();
-    assert.equal(hash(f, opt), hash(b, opt), 'Hashing should disregard the different constructor');
-
-
-    var ha, hb;
-    function F() {}
-    ha = hash(F, opt);
-
-    F.prototype.meaningOfLife = 42;
-    hb = hash(F, opt);
-
-    assert.equal(ha, hb, 'Hashing should disregard changes in the function\'s prototype');
-  });
-
-  it('unorderedArrays = false', function() {
-    var ha, hb;
-    ha = hash([1, 2, 3]);
-    hb = hash([3, 2, 1]);
-
-    assert.notEqual(ha, hb, 'Hashing should respect the order of array entries');
-  });
-
-  it('unorderedArrays = true', function() {
-    var opt = { unorderedArrays: true };
-
-    var ha, hb;
-    ha = hash([1, 2, 3], opt);
-    hb = hash([3, 2, 1], opt);
-
-    assert.equal(ha, hb, 'Hashing should not respect the order of array entries');
-
-    ha = hash([{a: 1}, {a: 2}], opt);
-    hb = hash([{a: 2}, {a: 1}], opt);
-
-    assert.equal(ha, hb, 'Hashing should not respect the order of array entries');
-  });
-
-  it('excludeKeys works', function() {
-    var ha, hb;
-    ha = hash({a: 1, b: 4}, { excludeKeys: function(key) { return key === 'b' } });
-    hb = hash({a: 1});
-
-    assert.equal(ha, hb, 'Hashing should ignore key `b`');
-  });
-
-  if (typeof Set !== 'undefined') {
-    it('unorderedSets = false', function() {
-      var opt = { unorderedSets: false };
-
-      var ha, hb;
-      ha = hash(new Set([1, 2, 3]), opt);
-      hb = hash(new Set([3, 2, 1]), opt);
-
-      assert.notEqual(ha, hb, 'Hashing should respect the order of Set entries');
-    });
-
-    it('unorderedSets = true', function() {
-      var ha, hb;
-      ha = hash(new Set([1, 2, 3]));
-      hb = hash(new Set([3, 2, 1]));
-
-      assert.equal(ha, hb, 'Hashing should not respect the order of Set entries');
-    });
-  }
-});

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

@@ -1,106 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var crypto = require('crypto');
-var stream = require('stream');
-var hash = require('../index');
-var validSha1 = /^[0-9a-f]{40}$/i;
-
-describe('hash() objects with custom class names', function() {
-  var builtinToString;
-  beforeEach(function() {
-    builtinToString = Object.prototype.toString;
-    Object.prototype.toString = function() {
-      if (this && typeof this.__className !== 'undefined') {
-        return this.__className;
-      }
-      
-      return builtinToString.apply(this, arguments);
-    };
-  });
-  
-  afterEach(function() {
-    Object.prototype.toString = builtinToString;
-  });
-  
-  it('should throw when trying to hash an unknown object', function() {
-    assert.throws(function() {
-      hash({a:1, __className: '[object Foo]'});
-    }, /Unknown object type "foo"/);
-    
-    assert.throws(function() {
-      hash({a:1, __className: 'Foo'});
-    }, /Unknown object type/);
-  });
-
-  it('should not throw when trying to hash an unknown object with ignoreUnknown', function() {
-    var opt = {ignoreUnknown: true};
-    
-    assert.ok(validSha1.test(hash({a:1, __className: '[object Foo]'}, opt)));
-  });
-
-  it('should not throw when trying to hash a weirdly-named object with ignoreUnknown', function() {
-    var opt = {ignoreUnknown: true};
-    
-    assert.ok(validSha1.test(hash({a:1, __className: 'Foo'}, opt)));
-  });
-  
-  it('should not delve further into a number of native types', function() {
-    var nativeTypes = [
-      'domwindow',
-      'process', 'timer', 'pipe', 'tcp', 'udp', 'tty', 'statwatcher',
-      'securecontext', 'connection', 'zlib', 'context', 'nodescript',
-      'httpparser', 'dataview', 'signal', 'fsevent', 'tlswrap'
-    ];
-    
-    for (var i = 0; i < nativeTypes.length; i++) {
-      var obj = { foobar: 1, __className: '[object ' + nativeTypes[i] + ']' };
-      var serialized = hash(obj, { algorithm: 'passthrough', encoding: 'utf8' });
-      assert.strictEqual(serialized, nativeTypes[i]);
-    }
-  });
-  
-  it('should hash xml based on its string representation', function() {
-    var obj = {
-      __className: '[object xml]',
-      toString: function() { return 'Bananä' }
-    };
-    
-    var serialized = hash(obj, { algorithm: 'passthrough', encoding: 'utf8' });
-    assert.strictEqual(serialized, 'xml:Bananä');
-  });
-  
-  it('should hash URLs based on its string representation', function() {
-    var obj = {
-      __className: '[object url]',
-      toString: function() { return 'https://example.com/' }
-    };
-    
-    var serialized = hash(obj, { algorithm: 'passthrough', encoding: 'utf8' });
-    assert.strictEqual(serialized, 'url:https://example.com/');
-  });
-  
-  it('should not hash blobs without ignoreUnknown', function() {
-    var obj = {
-      __className: '[object blob]'
-    };
-    
-    assert.throws(function() {
-      hash(obj);
-    }, /not supported/);
-  });
-  
-  it('should ignore blobs with ignoreUnknown', function() {
-    var obj = {
-      __className: '[object blob]'
-    };
-    
-    var serialized = hash(obj, {
-      algorithm: 'passthrough',
-      encoding: 'utf8',
-      ignoreUnknown: true
-    });
-    
-    assert.strictEqual(serialized, '[blob]');
-  });
-});

package/node_modules/object-hash/test/old-crypto.js

@@ -1,60 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var crypto = require('crypto');
-var hash = require('../index');
-var validSha1 = /^[0-9a-f]{40}$/i;
-var validBase64 = /^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/==]{4})$/;
-
-describe('hash() without crypto.getHashes', function() {
-  var getHashes_;
-  beforeEach(function() {
-    getHashes_ = crypto.getHashes;
-    delete crypto.getHashes;
-  });
-  
-  afterEach(function() {
-    crypto.getHashes = getHashes_;
-  });
-  
-  it('should work fine for SHA1', function() {
-    assert.ok(validSha1.test(hash(42)), 'hash some value');
-    assert.ok(validSha1.test(hash(NaN)), 'hash some value');
-  });
-});
-
-describe('hash() without Duplex streams', function() {
-  var createHash_;
-  beforeEach(function() {
-    createHash_ = crypto.createHash;
-    crypto.createHash = function(algorithm) {
-      var strm = createHash_(algorithm);
-      
-      return {
-        update: strm.write.bind(strm),
-        digest: strm.digest.bind(strm)
-      };
-    };
-  });
-  
-  afterEach(function() {
-    crypto.createHash = createHash_;
-  });
-  
-  it('should work fine for SHA1 without .write()/.read()', function() {
-    assert.ok(validSha1.test(hash(42)), 'hash some value');
-    assert.ok(validSha1.test(hash(NaN)), 'hash some value');
-  });
-  
-  it('should work fine for SHA1 without .write()/.read() with base64', function() {
-    assert.ok(validBase64.test(hash(42, {encoding: 'base64'})), 'hash some value');
-    assert.ok(validBase64.test(hash(NaN, {encoding: 'base64'})), 'hash some value');
-  });
-  
-  if (typeof Buffer !== 'undefined') {
-    it('should work fine for SHA1 without .write()/.read() with buffer', function() {
-      assert.ok(Buffer.isBuffer(hash(42, {encoding: 'buffer'})), 'hash some value');
-      assert.ok(Buffer.isBuffer(hash(NaN, {encoding: 'buffer'})), 'hash some value');
-    });
-  }
-});

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

@@ -1,36 +0,0 @@
-'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);
-  });
-});