@contrast/agent 4.32.10 → 4.32.12

package/node_modules/fast-safe-stringify/index.js

@@ -1,161 +0,0 @@
-module.exports = stringify
-stringify.default = stringify
-stringify.stable = deterministicStringify
-stringify.stableStringify = deterministicStringify
-
-var arr = []
-var replacerStack = []
-
-// Regular stringify
-function stringify (obj, replacer, spacer) {
-  decirc(obj, '', [], undefined)
-  var res
-  if (replacerStack.length === 0) {
-    res = JSON.stringify(obj, replacer, spacer)
-  } else {
-    res = JSON.stringify(obj, replaceGetterValues(replacer), spacer)
-  }
-  while (arr.length !== 0) {
-    var part = arr.pop()
-    if (part.length === 4) {
-      Object.defineProperty(part[0], part[1], part[3])
-    } else {
-      part[0][part[1]] = part[2]
-    }
-  }
-  return res
-}
-function decirc (val, k, stack, parent) {
-  var i
-  if (typeof val === 'object' && val !== null) {
-    for (i = 0; i < stack.length; i++) {
-      if (stack[i] === val) {
-        var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)
-        if (propertyDescriptor.get !== undefined) {
-          if (propertyDescriptor.configurable) {
-            Object.defineProperty(parent, k, { value: '[Circular]' })
-            arr.push([parent, k, val, propertyDescriptor])
-          } else {
-            replacerStack.push([val, k])
-          }
-        } else {
-          parent[k] = '[Circular]'
-          arr.push([parent, k, val])
-        }
-        return
-      }
-    }
-    stack.push(val)
-    // Optimize for Arrays. Big arrays could kill the performance otherwise!
-    if (Array.isArray(val)) {
-      for (i = 0; i < val.length; i++) {
-        decirc(val[i], i, stack, val)
-      }
-    } else {
-      var keys = Object.keys(val)
-      for (i = 0; i < keys.length; i++) {
-        var key = keys[i]
-        decirc(val[key], key, stack, val)
-      }
-    }
-    stack.pop()
-  }
-}
-
-// Stable-stringify
-function compareFunction (a, b) {
-  if (a < b) {
-    return -1
-  }
-  if (a > b) {
-    return 1
-  }
-  return 0
-}
-
-function deterministicStringify (obj, replacer, spacer) {
-  var tmp = deterministicDecirc(obj, '', [], undefined) || obj
-  var res
-  if (replacerStack.length === 0) {
-    res = JSON.stringify(tmp, replacer, spacer)
-  } else {
-    res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer)
-  }
-  while (arr.length !== 0) {
-    var part = arr.pop()
-    if (part.length === 4) {
-      Object.defineProperty(part[0], part[1], part[3])
-    } else {
-      part[0][part[1]] = part[2]
-    }
-  }
-  return res
-}
-
-function deterministicDecirc (val, k, stack, parent) {
-  var i
-  if (typeof val === 'object' && val !== null) {
-    for (i = 0; i < stack.length; i++) {
-      if (stack[i] === val) {
-        var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)
-        if (propertyDescriptor.get !== undefined) {
-          if (propertyDescriptor.configurable) {
-            Object.defineProperty(parent, k, { value: '[Circular]' })
-            arr.push([parent, k, val, propertyDescriptor])
-          } else {
-            replacerStack.push([val, k])
-          }
-        } else {
-          parent[k] = '[Circular]'
-          arr.push([parent, k, val])
-        }
-        return
-      }
-    }
-    if (typeof val.toJSON === 'function') {
-      return
-    }
-    stack.push(val)
-    // Optimize for Arrays. Big arrays could kill the performance otherwise!
-    if (Array.isArray(val)) {
-      for (i = 0; i < val.length; i++) {
-        deterministicDecirc(val[i], i, stack, val)
-      }
-    } else {
-      // Create a temporary object in the required way
-      var tmp = {}
-      var keys = Object.keys(val).sort(compareFunction)
-      for (i = 0; i < keys.length; i++) {
-        var key = keys[i]
-        deterministicDecirc(val[key], key, stack, val)
-        tmp[key] = val[key]
-      }
-      if (parent !== undefined) {
-        arr.push([parent, k, val])
-        parent[k] = tmp
-      } else {
-        return tmp
-      }
-    }
-    stack.pop()
-  }
-}
-
-// wraps replacer function to handle values we couldn't replace
-// and mark them as [Circular]
-function replaceGetterValues (replacer) {
-  replacer = replacer !== undefined ? replacer : function (k, v) { return v }
-  return function (key, val) {
-    if (replacerStack.length > 0) {
-      for (var i = 0; i < replacerStack.length; i++) {
-        var part = replacerStack[i]
-        if (part[1] === key && part[0] === val) {
-          val = '[Circular]'
-          replacerStack.splice(i, 1)
-          break
-        }
-      }
-    }
-    return replacer.call(this, key, val)
-  }
-}

package/node_modules/fast-safe-stringify/package.json

@@ -1,50 +0,0 @@
-{
-  "name": "fast-safe-stringify",
-  "version": "2.0.7",
-  "description": "Safely and quickly serialize JavaScript objects",
-  "keywords": [
-    "stable",
-    "stringify",
-    "JSON",
-    "JSON.stringify",
-    "safe",
-    "serialize"
-  ],
-  "main": "index.js",
-  "scripts": {
-    "test": "standard && tap --no-esm test.js test-stable.js",
-    "benchmark": "node benchmark.js"
-  },
-  "author": "David Mark Clements",
-  "contributors": [
-    "Ruben Bridgewater",
-    "Matteo Collina",
-    "Ben Gourley",
-    "Gabriel Lesperance",
-    "Alex Liu",
-    "Christoph Walcher",
-    "Nicholas Young"
-  ],
-  "license": "MIT",
-  "typings": "index",
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "clone": "^2.1.0",
-    "json-stringify-safe": "^5.0.1",
-    "standard": "^11.0.0",
-    "tap": "^12.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/davidmarkclements/fast-safe-stringify.git"
-  },
-  "bugs": {
-    "url": "https://github.com/davidmarkclements/fast-safe-stringify/issues"
-  },
-  "homepage": "https://github.com/davidmarkclements/fast-safe-stringify#readme",
-  "dependencies": {}
-
-,"_resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz"
-,"_integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA=="
-,"_from": "fast-safe-stringify@2.0.7"
-}

package/node_modules/fast-safe-stringify/readme.md

@@ -1,154 +0,0 @@
-# fast-safe-stringify
-
-Safe and fast serialization alternative to [JSON.stringify][].
-
-Gracefully handles circular structures instead of throwing.
-
-Provides a deterministic ("stable") version as well that will also gracefully
-handle circular structures. See the example below for further information.
-
-## Usage
-
-The same as [JSON.stringify][].
-
-`stringify(value[, replacer[, space]])`
-
-```js
-const safeStringify = require('fast-safe-stringify')
-const o = { a: 1 }
-o.o = o
-
-console.log(safeStringify(o))
-// '{"a":1,"o":"[Circular]"}'
-console.log(JSON.stringify(o))
-// TypeError: Converting circular structure to JSON
-
-function replacer(key, value) {
-  console.log('Key:', JSON.stringify(key), 'Value:', JSON.stringify(value))
-  // Remove the circular structure
-  if (value === '[Circular]') {
-    return
-  }
-  return value
-}
-const serialized = safeStringify(o, replacer, 2)
-// Key: "" Value: {"a":1,"o":"[Circular]"}
-// Key: "a" Value: 1
-// Key: "o" Value: "[Circular]"
-console.log(serialized)
-// {
-//  "a": 1
-// }
-```
-
-Using the deterministic version also works the same:
-
-```js
-const safeStringify = require('fast-safe-stringify')
-const o = { b: 1, a: 0 }
-o.o = o
-
-console.log(safeStringify(o))
-// '{"b":1,"a":0,"o":"[Circular]"}'
-console.log(safeStringify.stableStringify(o))
-// '{"a":0,"b":1,"o":"[Circular]"}'
-console.log(JSON.stringify(o))
-// TypeError: Converting circular structure to JSON
-```
-
-A faster and side-effect free implementation is available in the
-[safe-stable-stringify][] module. However it is still considered experimental
-due to a new and more complex implementation.
-
-## Differences to JSON.stringify
-
-In general the behavior is identical to [JSON.stringify][]. The [`replacer`][]
-and [`space`][] options are also available.
-
-A few exceptions exist to [JSON.stringify][] while using [`toJSON`][] or
-[`replacer`][]:
-
-### Regular safe stringify
-
-- Manipulating a circular structure of the passed in value in a `toJSON` or the
-  `replacer` is not possible! It is possible for any other value and property.
-
-- In case a circular structure is detected and the [`replacer`][] is used it
-  will receive the string `[Circular]` as the argument instead of the circular
-  object itself.
-
-### Deterministic ("stable") safe stringify
-
-- Manipulating the input object either in a [`toJSON`][] or the [`replacer`][]
-  function will not have any effect on the output. The output entirely relies on
-  the shape the input value had at the point passed to the stringify function!
-
-- In case a circular structure is detected and the [`replacer`][] is used it
-  will receive the string `[Circular]` as the argument instead of the circular
-  object itself.
-
-A side effect free variation without these limitations can be found as well
-([`safe-stable-stringify`][]). It is also faster than the current
-implementation. It is still considered experimental due to a new and more
-complex implementation.
-
-## Benchmarks
-
-Although not JSON, the Node.js `util.inspect` method can be used for similar
-purposes (e.g. logging) and also handles circular references.
-
-Here we compare `fast-safe-stringify` with some alternatives:
-(Lenovo T450s with a i7-5600U CPU using Node.js 8.9.4)
-
-```md
-fast-safe-stringify:   simple object x 1,121,497 ops/sec ±0.75% (97 runs sampled)
-fast-safe-stringify:   circular      x 560,126 ops/sec ±0.64% (96 runs sampled)
-fast-safe-stringify:   deep          x 32,472 ops/sec ±0.57% (95 runs sampled)
-fast-safe-stringify:   deep circular x 32,513 ops/sec ±0.80% (92 runs sampled)
-
-util.inspect:          simple object x 272,837 ops/sec ±1.48% (90 runs sampled)
-util.inspect:          circular      x 116,896 ops/sec ±1.19% (95 runs sampled)
-util.inspect:          deep          x 19,382 ops/sec ±0.66% (92 runs sampled)
-util.inspect:          deep circular x 18,717 ops/sec ±0.63% (96 runs sampled)
-
-json-stringify-safe:   simple object x 233,621 ops/sec ±0.97% (94 runs sampled)
-json-stringify-safe:   circular      x 110,409 ops/sec ±1.85% (95 runs sampled)
-json-stringify-safe:   deep          x 8,705 ops/sec ±0.87% (96 runs sampled)
-json-stringify-safe:   deep circular x 8,336 ops/sec ±2.20% (93 runs sampled)
-```
-
-For stable stringify comparisons, see the performance benchmarks in the
-[`safe-stable-stringify`][] readme.
-
-## Protip
-
-Whether `fast-safe-stringify` or alternatives are used: if the use case
-consists of deeply nested objects without circular references the following
-pattern will give best results.
-Shallow or one level nested objects on the other hand will slow down with it.
-It is entirely dependant on the use case.
-
-```js
-const stringify = require('fast-safe-stringify')
-
-function tryJSONStringify (obj) {
-  try { return JSON.stringify(obj) } catch (_) {}
-}
-
-const serializedString = tryJSONStringify(deep) || stringify(deep)
-```
-
-## Acknowledgements
-
-Sponsored by [nearForm](http://nearform.com)
-
-## License
-
-MIT
-
-[`replacer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20replacer%20parameter
-[`safe-stable-stringify`]: https://github.com/BridgeAR/safe-stable-stringify
-[`space`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20space%20argument
-[`toJSON`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON()_behavior
-[benchmark]: https://github.com/epoberezkin/fast-json-stable-stringify/blob/67f688f7441010cfef91a6147280cc501701e83b/benchmark
-[JSON.stringify]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify

package/node_modules/fast-safe-stringify/test-stable.js

@@ -1,311 +0,0 @@
-const test = require('tap').test
-const fss = require('./').stable
-const clone = require('clone')
-const s = JSON.stringify
-
-test('circular reference to root', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.circle = fixture
-  const expected = s(
-    { circle: '[Circular]', name: 'Tywin Lannister' }
-  )
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('circular getter reference to root', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    get circle () {
-      return fixture
-    }
-  }
-
-  const expected = s(
-    { circle: '[Circular]', name: 'Tywin Lannister' }
-  )
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('nested circular reference to root', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.id = { circle: fixture }
-  const expected = s(
-    { id: { circle: '[Circular]' }, name: 'Tywin Lannister' }
-  )
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('child circular reference', function (assert) {
-  const fixture = { name: 'Tywin Lannister', child: { name: 'Tyrion Lannister' } }
-  fixture.child.dinklage = fixture.child
-  const expected = s({
-    child: {
-      dinklage: '[Circular]', name: 'Tyrion Lannister'
-    },
-    name: 'Tywin Lannister'
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('nested child circular reference', function (assert) {
-  const fixture = { name: 'Tywin Lannister', child: { name: 'Tyrion Lannister' } }
-  fixture.child.actor = { dinklage: fixture.child }
-  const expected = s({
-    child: {
-      actor: { dinklage: '[Circular]' }, name: 'Tyrion Lannister'
-    },
-    name: 'Tywin Lannister'
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('circular objects in an array', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.hand = [fixture, fixture]
-  const expected = s({
-    hand: ['[Circular]', '[Circular]'], name: 'Tywin Lannister'
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('nested circular references in an array', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    offspring: [{ name: 'Tyrion Lannister' }, { name: 'Cersei Lannister' }]
-  }
-  fixture.offspring[0].dinklage = fixture.offspring[0]
-  fixture.offspring[1].headey = fixture.offspring[1]
-
-  const expected = s({
-    name: 'Tywin Lannister',
-    offspring: [
-      { dinklage: '[Circular]', name: 'Tyrion Lannister' },
-      { headey: '[Circular]', name: 'Cersei Lannister' }
-    ]
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('circular arrays', function (assert) {
-  const fixture = []
-  fixture.push(fixture, fixture)
-  const expected = s(['[Circular]', '[Circular]'])
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('nested circular arrays', function (assert) {
-  const fixture = []
-  fixture.push(
-    { name: 'Jon Snow', bastards: fixture },
-    { name: 'Ramsay Bolton', bastards: fixture }
-  )
-  const expected = s([
-    { bastards: '[Circular]', name: 'Jon Snow' },
-    { bastards: '[Circular]', name: 'Ramsay Bolton' }
-  ])
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('repeated non-circular references in objects', function (assert) {
-  const daenerys = { name: 'Daenerys Targaryen' }
-  const fixture = {
-    motherOfDragons: daenerys,
-    queenOfMeereen: daenerys
-  }
-  const expected = s(fixture)
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('repeated non-circular references in arrays', function (assert) {
-  const daenerys = { name: 'Daenerys Targaryen' }
-  const fixture = [daenerys, daenerys]
-  const expected = s(fixture)
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('double child circular reference', function (assert) {
-  // create circular reference
-  const child = { name: 'Tyrion Lannister' }
-  child.dinklage = child
-
-  // include it twice in the fixture
-  const fixture = { name: 'Tywin Lannister', childA: child, childB: child }
-  const cloned = clone(fixture)
-  const expected = s({
-    childA: {
-      dinklage: '[Circular]', name: 'Tyrion Lannister'
-    },
-    childB: {
-      dinklage: '[Circular]', name: 'Tyrion Lannister'
-    },
-    name: 'Tywin Lannister'
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-
-  // check if the fixture has not been modified
-  assert.deepEqual(fixture, cloned)
-  assert.end()
-})
-
-test('child circular reference with toJSON', function (assert) {
-  // Create a test object that has an overriden `toJSON` property
-  TestObject.prototype.toJSON = function () { return { special: 'case' } }
-  function TestObject (content) {}
-
-  // Creating a simple circular object structure
-  const parentObject = {}
-  parentObject.childObject = new TestObject()
-  parentObject.childObject.parentObject = parentObject
-
-  // Creating a simple circular object structure
-  const otherParentObject = new TestObject()
-  otherParentObject.otherChildObject = {}
-  otherParentObject.otherChildObject.otherParentObject = otherParentObject
-
-  // Making sure our original tests work
-  assert.deepEqual(parentObject.childObject.parentObject, parentObject)
-  assert.deepEqual(otherParentObject.otherChildObject.otherParentObject, otherParentObject)
-
-  // Should both be idempotent
-  assert.equal(fss(parentObject), '{"childObject":{"special":"case"}}')
-  assert.equal(fss(otherParentObject), '{"special":"case"}')
-
-  // Therefore the following assertion should be `true`
-  assert.deepEqual(parentObject.childObject.parentObject, parentObject)
-  assert.deepEqual(otherParentObject.otherChildObject.otherParentObject, otherParentObject)
-
-  assert.end()
-})
-
-test('null object', function (assert) {
-  const expected = s(null)
-  const actual = fss(null)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('null property', function (assert) {
-  const expected = s({ f: null })
-  const actual = fss({ f: null })
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('nested child circular reference in toJSON', function (assert) {
-  var circle = { some: 'data' }
-  circle.circle = circle
-  var a = {
-    b: {
-      toJSON: function () {
-        a.b = 2
-        return '[Redacted]'
-      }
-    },
-    baz: {
-      circle,
-      toJSON: function () {
-        a.baz = circle
-        return '[Redacted]'
-      }
-    }
-  }
-  var o = {
-    a,
-    bar: a
-  }
-
-  const expected = s({
-    a: {
-      b: '[Redacted]',
-      baz: '[Redacted]'
-    },
-    bar: {
-      // TODO: This is a known limitation of the current implementation.
-      // The ideal result would be:
-      //
-      // b: 2,
-      // baz: {
-      //   circle: '[Circular]',
-      //   some: 'data'
-      // }
-      //
-      b: '[Redacted]',
-      baz: '[Redacted]'
-    }
-  })
-  const actual = fss(o)
-  assert.is(actual, expected)
-  assert.end()
-})
-
-test('circular getters are restored when stringified', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    get circle () {
-      return fixture
-    }
-  }
-  fss(fixture)
-
-  assert.is(fixture.circle, fixture)
-  assert.end()
-})
-
-test('non-configurable circular getters use a replacer instead of markers', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  Object.defineProperty(fixture, 'circle', {
-    configurable: false,
-    get: function () { return fixture },
-    enumerable: true
-  })
-
-  fss(fixture)
-
-  assert.is(fixture.circle, fixture)
-  assert.end()
-})
-
-test('getter child circular reference', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister',
-      get dinklage () { return fixture.child }
-    },
-    get self () { return fixture }
-  }
-
-  const expected = s({
-    child: {
-      dinklage: '[Circular]', name: 'Tyrion Lannister'
-    },
-    name: 'Tywin Lannister',
-    self: '[Circular]'
-  })
-  const actual = fss(fixture)
-  assert.is(actual, expected)
-  assert.end()
-})