1 files changed, 0 insertions, 404 deletions
diff --git a/together/node_modules/fast-safe-stringify/test-stable.js b/together/node_modules/fast-safe-stringify/test-stable.js
deleted file mode 100644
index c55b95c..0000000
--- a/together/node_modules/fast-safe-stringify/test-stable.js
+++ /dev/null
@@ -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()
-})