@corellium/corellium-cli 1.2.0 → 1.2.1

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

@@ -1,90 +0,0 @@
-{
-  "_args": [
-    [
-      "fast-safe-stringify@2.1.1",
-      "/home/sam/source/corellium/corellium-cli"
-    ]
-  ],
-  "_from": "fast-safe-stringify@2.1.1",
-  "_id": "fast-safe-stringify@2.1.1",
-  "_inBundle": false,
-  "_integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
-  "_location": "/fast-safe-stringify",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "fast-safe-stringify@2.1.1",
-    "name": "fast-safe-stringify",
-    "escapedName": "fast-safe-stringify",
-    "rawSpec": "2.1.1",
-    "saveSpec": null,
-    "fetchSpec": "2.1.1"
-  },
-  "_requiredBy": [
-    "/superagent"
-  ],
-  "_resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
-  "_spec": "2.1.1",
-  "_where": "/home/sam/source/corellium/corellium-cli",
-  "author": {
-    "name": "David Mark Clements"
-  },
-  "bugs": {
-    "url": "https://github.com/davidmarkclements/fast-safe-stringify/issues"
-  },
-  "contributors": [
-    {
-      "name": "Ruben Bridgewater"
-    },
-    {
-      "name": "Matteo Collina"
-    },
-    {
-      "name": "Ben Gourley"
-    },
-    {
-      "name": "Gabriel Lesperance"
-    },
-    {
-      "name": "Alex Liu"
-    },
-    {
-      "name": "Christoph Walcher"
-    },
-    {
-      "name": "Nicholas Young"
-    }
-  ],
-  "dependencies": {},
-  "description": "Safely and quickly serialize JavaScript objects",
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "clone": "^2.1.0",
-    "json-stringify-safe": "^5.0.1",
-    "standard": "^11.0.0",
-    "tap": "^12.0.0"
-  },
-  "homepage": "https://github.com/davidmarkclements/fast-safe-stringify#readme",
-  "keywords": [
-    "stable",
-    "stringify",
-    "JSON",
-    "JSON.stringify",
-    "safe",
-    "serialize"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "fast-safe-stringify",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/davidmarkclements/fast-safe-stringify.git"
-  },
-  "scripts": {
-    "benchmark": "node benchmark.js",
-    "test": "standard && tap --no-esm test.js test-stable.js"
-  },
-  "typings": "index",
-  "version": "2.1.1"
-}

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

@@ -1,170 +0,0 @@
-# fast-safe-stringify
-
-Safe and fast serialization alternative to [JSON.stringify][].
-
-Gracefully handles circular structures instead of throwing in most cases.
-It could return an error string if the circular object is too complex to analyze,
-e.g. in case there are proxies involved.
-
-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[, options]]])`
-
-```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
-}
-
-// those are also defaults limits when no options object is passed into safeStringify
-// configure it to lower the limit.
-const options = {
-  depthLimit: Number.MAX_SAFE_INTEGER,
-  edgesLimit: Number.MAX_SAFE_INTEGER
-};
-
-const serialized = safeStringify(o, replacer, 2, options)
-// 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.
-
-### Replace strings constants
-
-- `[Circular]` - when same reference is found
-- `[...]` - when some limit from options object is reached
-
-## 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,404 +0,0 @@
-const test = require('tap').test
-const fss = require('./').stable
-const clone = require('clone')
-const s = JSON.stringify
-const stream = require('stream')
-
-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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(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.equal(actual, expected)
-
-  // check if the fixture has not been modified
-  assert.same(fixture, cloned)
-  assert.end()
-})
-
-test('child circular reference with toJSON', function (assert) {
-  // Create a test object that has an overridden `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.same(parentObject.childObject.parentObject, parentObject)
-  assert.same(
-    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.same(parentObject.childObject.parentObject, parentObject)
-  assert.same(
-    otherParentObject.otherChildObject.otherParentObject,
-    otherParentObject
-  )
-
-  assert.end()
-})
-
-test('null object', function (assert) {
-  const expected = s(null)
-  const actual = fss(null)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('null property', function (assert) {
-  const expected = s({ f: null })
-  const actual = fss({ f: null })
-  assert.equal(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.equal(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.equal(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.equal(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.equal(actual, expected)
-  assert.end()
-})
-
-test('Proxy throwing', function (assert) {
-  assert.plan(1)
-  const s = new stream.PassThrough()
-  s.resume()
-  s.write('', () => {
-    assert.end()
-  })
-  const actual = fss({ s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) })
-  assert.equal(actual, '"[unable to serialize, circular reference is too complex to analyze]"')
-})
-
-test('depthLimit option - will replace deep objects', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister'
-    },
-    get self () {
-      return fixture
-    }
-  }
-
-  const expected = s({
-    child: '[...]',
-    name: 'Tywin Lannister',
-    self: '[Circular]'
-  })
-  const actual = fss(fixture, undefined, undefined, {
-    depthLimit: 1,
-    edgesLimit: 1
-  })
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('edgesLimit option - will replace deep objects', function (assert) {
-  const fixture = {
-    object: {
-      1: { test: 'test' },
-      2: { test: 'test' },
-      3: { test: 'test' },
-      4: { test: 'test' }
-    },
-    array: [
-      { test: 'test' },
-      { test: 'test' },
-      { test: 'test' },
-      { test: 'test' }
-    ],
-    get self () {
-      return fixture
-    }
-  }
-
-  const expected = s({
-    array: [{ test: 'test' }, { test: 'test' }, { test: 'test' }, '[...]'],
-    object: {
-      1: { test: 'test' },
-      2: { test: 'test' },
-      3: { test: 'test' },
-      4: '[...]'
-    },
-    self: '[Circular]'
-  })
-  const actual = fss(fixture, undefined, undefined, {
-    depthLimit: 3,
-    edgesLimit: 3
-  })
-  assert.equal(actual, expected)
-  assert.end()
-})