@corellium/corellium-cli 1.2.1 → 1.2.2

package/node_modules/escalade/sync/index.mjs

@@ -0,0 +1,18 @@
+import { dirname, resolve } from 'path';
+import { readdirSync, statSync } from 'fs';
+
+export default function (start, callback) {
+	let dir = resolve('.', start);
+	let tmp, stats = statSync(dir);
+
+	if (!stats.isDirectory()) {
+		dir = dirname(dir);
+	}
+
+	while (true) {
+		tmp = callback(dir, readdirSync(dir));
+		if (tmp) return resolve(dir, tmp);
+		dir = dirname(tmp = dir);
+		if (tmp === dir) break;
+	}
+}

package/node_modules/fast-safe-stringify/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+sudo: false
+node_js:
+- '4'
+- '6'
+- '8'
+- '9'
+- '10'

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

@@ -0,0 +1,17 @@
+# Changelog
+
+## v.2.0.0
+
+Features
+
+- Added stable-stringify (see documentation)
+- Support replacer
+- Support spacer
+- toJSON support without forceDecirc property
+- Improved performance
+
+Breaking changes
+
+- Manipulating the input value in a `toJSON` function is not possible anymore in
+  all cases (see documentation)
+- Dropped support for e.g. IE8 and Node.js < 4

package/node_modules/fast-safe-stringify/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 David Mark Clements
+Copyright (c) 2017 David Mark Clements & Matteo Collina
+Copyright (c) 2018 David Mark Clements, Matteo Collina & Ruben Bridgewater 
+
+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/fast-safe-stringify/benchmark.js

@@ -0,0 +1,137 @@
+const Benchmark = require('benchmark')
+const suite = new Benchmark.Suite()
+const { inspect } = require('util')
+const jsonStringifySafe = require('json-stringify-safe')
+const fastSafeStringify = require('./')
+
+const array = new Array(10).fill(0).map((_, i) => i)
+const obj = { foo: array }
+const circ = JSON.parse(JSON.stringify(obj))
+circ.o = { obj: circ, array }
+const circGetters = JSON.parse(JSON.stringify(obj))
+Object.assign(circGetters, { get o () { return { obj: circGetters, array } } })
+
+const deep = require('./package.json')
+deep.deep = JSON.parse(JSON.stringify(deep))
+deep.deep.deep = JSON.parse(JSON.stringify(deep))
+deep.deep.deep.deep = JSON.parse(JSON.stringify(deep))
+deep.array = array
+
+const deepCirc = JSON.parse(JSON.stringify(deep))
+deepCirc.deep.deep.deep.circ = deepCirc
+deepCirc.deep.deep.circ = deepCirc
+deepCirc.deep.circ = deepCirc
+deepCirc.array = array
+
+const deepCircGetters = JSON.parse(JSON.stringify(deep))
+for (let i = 0; i < 10; i++) {
+  deepCircGetters[i.toString()] = {
+    deep: {
+      deep: {
+        get circ () { return deep.deep },
+        deep: { get circ () { return deep.deep.deep } }
+      },
+      get circ () { return deep }
+    },
+    get array () { return array }
+  }
+}
+
+const deepCircNonCongifurableGetters = JSON.parse(JSON.stringify(deep))
+Object.defineProperty(deepCircNonCongifurableGetters.deep.deep.deep, 'circ', {
+  get: () => deepCircNonCongifurableGetters,
+  enumerable: true,
+  configurable: false
+})
+Object.defineProperty(deepCircNonCongifurableGetters.deep.deep, 'circ', {
+  get: () => deepCircNonCongifurableGetters,
+  enumerable: true,
+  configurable: false
+})
+Object.defineProperty(deepCircNonCongifurableGetters.deep, 'circ', {
+  get: () => deepCircNonCongifurableGetters,
+  enumerable: true,
+  configurable: false
+})
+Object.defineProperty(deepCircNonCongifurableGetters, 'array', {
+  get: () => array,
+  enumerable: true,
+  configurable: false
+})
+
+suite.add('util.inspect:          simple object                 ', function () {
+  inspect(obj, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          circular                      ', function () {
+  inspect(circ, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          circular getters              ', function () {
+  inspect(circGetters, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          deep                          ', function () {
+  inspect(deep, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          deep circular                 ', function () {
+  inspect(deepCirc, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          large deep circular getters   ', function () {
+  inspect(deepCircGetters, { showHidden: false, depth: null })
+})
+suite.add('util.inspect:          deep non-conf circular getters', function () {
+  inspect(deepCircNonCongifurableGetters, { showHidden: false, depth: null })
+})
+
+suite.add('\njson-stringify-safe:   simple object                 ', function () {
+  jsonStringifySafe(obj)
+})
+suite.add('json-stringify-safe:   circular                      ', function () {
+  jsonStringifySafe(circ)
+})
+suite.add('json-stringify-safe:   circular getters              ', function () {
+  jsonStringifySafe(circGetters)
+})
+suite.add('json-stringify-safe:   deep                          ', function () {
+  jsonStringifySafe(deep)
+})
+suite.add('json-stringify-safe:   deep circular                 ', function () {
+  jsonStringifySafe(deepCirc)
+})
+suite.add('json-stringify-safe:   large deep circular getters   ', function () {
+  jsonStringifySafe(deepCircGetters)
+})
+suite.add('json-stringify-safe:   deep non-conf circular getters', function () {
+  jsonStringifySafe(deepCircNonCongifurableGetters)
+})
+
+suite.add('\nfast-safe-stringify:   simple object                 ', function () {
+  fastSafeStringify(obj)
+})
+suite.add('fast-safe-stringify:   circular                      ', function () {
+  fastSafeStringify(circ)
+})
+suite.add('fast-safe-stringify:   circular getters              ', function () {
+  fastSafeStringify(circGetters)
+})
+suite.add('fast-safe-stringify:   deep                          ', function () {
+  fastSafeStringify(deep)
+})
+suite.add('fast-safe-stringify:   deep circular                 ', function () {
+  fastSafeStringify(deepCirc)
+})
+suite.add('fast-safe-stringify:   large deep circular getters   ', function () {
+  fastSafeStringify(deepCircGetters)
+})
+suite.add('fast-safe-stringify:   deep non-conf circular getters', function () {
+  fastSafeStringify(deepCircNonCongifurableGetters)
+})
+
+// add listeners
+suite.on('cycle', function (event) {
+  console.log(String(event.target))
+})
+
+suite.on('complete', function () {
+  console.log('\nFastest is ' + this.filter('fastest').map('name'))
+})
+
+suite.run({ delay: 1, minSamples: 150 })

package/node_modules/fast-safe-stringify/index.d.ts

@@ -0,0 +1,23 @@
+declare function stringify(
+  value: any,
+  replacer?: (key: string, value: any) => any,
+  space?: string | number,
+  options?: { depthLimit: number | undefined; edgesLimit: number | undefined }
+): string;
+
+declare namespace stringify {
+  export function stable(
+    value: any,
+    replacer?: (key: string, value: any) => any,
+    space?: string | number,
+    options?: { depthLimit: number | undefined; edgesLimit: number | undefined }
+  ): string;
+  export function stableStringify(
+    value: any,
+    replacer?: (key: string, value: any) => any,
+    space?: string | number,
+    options?: { depthLimit: number | undefined; edgesLimit: number | undefined }
+  ): string;
+}
+
+export default stringify;

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

@@ -0,0 +1,229 @@
+module.exports = stringify
+stringify.default = stringify
+stringify.stable = deterministicStringify
+stringify.stableStringify = deterministicStringify
+
+var LIMIT_REPLACE_NODE = '[...]'
+var CIRCULAR_REPLACE_NODE = '[Circular]'
+
+var arr = []
+var replacerStack = []
+
+function defaultOptions () {
+  return {
+    depthLimit: Number.MAX_SAFE_INTEGER,
+    edgesLimit: Number.MAX_SAFE_INTEGER
+  }
+}
+
+// Regular stringify
+function stringify (obj, replacer, spacer, options) {
+  if (typeof options === 'undefined') {
+    options = defaultOptions()
+  }
+
+  decirc(obj, '', 0, [], undefined, 0, options)
+  var res
+  try {
+    if (replacerStack.length === 0) {
+      res = JSON.stringify(obj, replacer, spacer)
+    } else {
+      res = JSON.stringify(obj, replaceGetterValues(replacer), spacer)
+    }
+  } catch (_) {
+    return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
+  } finally {
+    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 setReplace (replace, val, k, parent) {
+  var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)
+  if (propertyDescriptor.get !== undefined) {
+    if (propertyDescriptor.configurable) {
+      Object.defineProperty(parent, k, { value: replace })
+      arr.push([parent, k, val, propertyDescriptor])
+    } else {
+      replacerStack.push([val, k, replace])
+    }
+  } else {
+    parent[k] = replace
+    arr.push([parent, k, val])
+  }
+}
+
+function decirc (val, k, edgeIndex, stack, parent, depth, options) {
+  depth += 1
+  var i
+  if (typeof val === 'object' && val !== null) {
+    for (i = 0; i < stack.length; i++) {
+      if (stack[i] === val) {
+        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent)
+        return
+      }
+    }
+
+    if (
+      typeof options.depthLimit !== 'undefined' &&
+      depth > options.depthLimit
+    ) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent)
+      return
+    }
+
+    if (
+      typeof options.edgesLimit !== 'undefined' &&
+      edgeIndex + 1 > options.edgesLimit
+    ) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent)
+      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, i, stack, val, depth, options)
+      }
+    } else {
+      var keys = Object.keys(val)
+      for (i = 0; i < keys.length; i++) {
+        var key = keys[i]
+        decirc(val[key], key, i, stack, val, depth, options)
+      }
+    }
+    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, options) {
+  if (typeof options === 'undefined') {
+    options = defaultOptions()
+  }
+
+  var tmp = deterministicDecirc(obj, '', 0, [], undefined, 0, options) || obj
+  var res
+  try {
+    if (replacerStack.length === 0) {
+      res = JSON.stringify(tmp, replacer, spacer)
+    } else {
+      res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer)
+    }
+  } catch (_) {
+    return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
+  } finally {
+    // Ensure that we restore the object as it was.
+    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, edgeIndex, stack, parent, depth, options) {
+  depth += 1
+  var i
+  if (typeof val === 'object' && val !== null) {
+    for (i = 0; i < stack.length; i++) {
+      if (stack[i] === val) {
+        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent)
+        return
+      }
+    }
+    try {
+      if (typeof val.toJSON === 'function') {
+        return
+      }
+    } catch (_) {
+      return
+    }
+
+    if (
+      typeof options.depthLimit !== 'undefined' &&
+      depth > options.depthLimit
+    ) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent)
+      return
+    }
+
+    if (
+      typeof options.edgesLimit !== 'undefined' &&
+      edgeIndex + 1 > options.edgesLimit
+    ) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent)
+      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, i, stack, val, depth, options)
+      }
+    } 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, i, stack, val, depth, options)
+        tmp[key] = val[key]
+      }
+      if (typeof 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 replaced value
+function replaceGetterValues (replacer) {
+  replacer =
+    typeof 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 = part[2]
+          replacerStack.splice(i, 1)
+          break
+        }
+      }
+    }
+    return replacer.call(this, key, val)
+  }
+}

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

@@ -0,0 +1,46 @@
+{
+  "name": "fast-safe-stringify",
+  "version": "2.1.1",
+  "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": {}
+}

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

@@ -0,0 +1,170 @@
+# 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