feat: Vendor prod dependency on json-stringify-safe (#2910)

svix-mman · web-flow · commit ae85b3a862a2 · 2026-02-27T13:44:45.000+02:00
diff --git a/lib/interceptor.js b/lib/interceptor.js
@@ -1,10 +1,10 @@
 'use strict'
 
 const fs = require('node:fs')
-const stringify = require('json-stringify-safe')
 const querystring = require('node:querystring')
 const { URL, URLSearchParams } = require('node:url')
 
+const stringify = require('./stringify')
 const common = require('./common')
 const { remove } = require('./intercept')
 const matchBody = require('./match_body')
diff --git a/lib/stringify.js b/lib/stringify.js
@@ -0,0 +1,62 @@
+'use strict'
+/**
+ * @see https://github.com/moll/json-stringify-safe/blob/02cfafd45f06d076ac4bf0dd28be6738a07a72f9/stringify.js
+ * @license
+ * The ISC License
+ *
+ * Copyright (c) Isaac Z. Schlueter and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * @param {*} obj
+ * @returns {string}
+ */
+function stringify(obj) {
+  return JSON.stringify(obj, safeReplacer())
+}
+
+/**
+ * @param {Array<*>} stack
+ * @param {Array<string>} keys
+ * @param {*} value
+ * @returns {string}
+ */
+function cycleReplacer(stack, keys, value) {
+  if (stack[0] === value) return '[Circular ~]'
+  return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`
+}
+
+/**
+ * @param {Array<*>} [stack]
+ * @param {Array<string>} [keys]
+ * @returns {(key: string, value: *) => *} */
+function safeReplacer(stack = [], keys = []) {
+  return function (key, value) {
+    if (stack.length > 0) {
+      const thisPos = stack.indexOf(this)
+      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
+      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+      if (~stack.indexOf(value)) {
+        value = cycleReplacer(stack, keys, value)
+      }
+    } else {
+      stack.push(value)
+    }
+
+    return value
+  }
+}
+
+module.exports = stringify
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -22,8 +22,7 @@
   "main": "./index.js",
   "types": "types",
   "dependencies": {
-    "@mswjs/interceptors": "^0.41.2",
-    "json-stringify-safe": "^5.0.1"
+    "@mswjs/interceptors": "^0.41.2"
   },
   "devDependencies": {
     "@definitelytyped/dtslint": "^0.0.163",
diff --git a/tests/test_stringify.js b/tests/test_stringify.js
@@ -0,0 +1,91 @@
+'use strict'
+
+const { expect } = require('chai')
+const stringify = require('../lib/stringify')
+
+describe('stringify', () => {
+  it('should stringify a number', () => {
+    expect(stringify(42)).to.equal('42')
+  })
+
+  it('should stringify a string', () => {
+    expect(stringify('foo')).to.equal('"foo"')
+  })
+
+  it('should stringify a boolean', () => {
+    expect(stringify(true)).to.equal('true')
+  })
+
+  it('should stringify null', () => {
+    expect(stringify(null)).to.equal('null')
+  })
+
+  it('should stringify an object', () => {
+    expect(stringify({ foo: 'bar' })).to.equal('{"foo":"bar"}')
+  })
+
+  it('should stringify an array', () => {
+    expect(stringify([1, 2, 3])).to.equal('[1,2,3]')
+  })
+
+  it('should handle a circular reference in an object', () => {
+    const obj = { foo: 'bar' }
+    obj.self = obj
+    expect(stringify(obj)).to.equal('{"foo":"bar","self":"[Circular ~]"}')
+  })
+
+  it('should handle a circular reference in an array', () => {
+    const arr = [1, 2, 3]
+    arr.push(arr)
+    expect(stringify(arr)).to.equal('[1,2,3,"[Circular ~]"]')
+  })
+
+  it('should handle a nested circular reference', () => {
+    const obj = { name: 'parent' }
+    obj.child = { name: 'child', parent: obj }
+    expect(stringify(obj)).to.equal(
+      '{"name":"parent","child":{"name":"child","parent":"[Circular ~]"}}',
+    )
+  })
+
+  it('should handle a deeply nested circular reference with path notation', () => {
+    const obj = { level1: { level2: { level3: {} } } }
+    obj.level1.level2.level3.self = obj.level1
+    expect(stringify(obj)).to.equal(
+      '{"level1":{"level2":{"level3":{"self":"[Circular ~.level1]"}}}}',
+    )
+  })
+
+  it('should handle multiple references to the same object', () => {
+    const shared = { value: 'shared' }
+    const obj = { a: shared, b: shared }
+    expect(stringify(obj)).to.equal(
+      '{"a":{"value":"shared"},"b":{"value":"shared"}}',
+    )
+  })
+
+  it('should handle an object with a toJSON method that returns a circular reference', () => {
+    const obj = {
+      name: 'circular',
+      toJSON() {
+        return this
+      },
+    }
+    expect(stringify(obj)).to.equal('{"name":"circular"}')
+  })
+
+  it('should handle an object with circular references in different properties', () => {
+    const obj = { a: {}, b: {} }
+    obj.a.self = obj.a
+    obj.b.self = obj.b
+    expect(stringify(obj)).to.equal(
+      '{"a":{"self":"[Circular ~.a]"},"b":{"self":"[Circular ~.b]"}}',
+    )
+  })
+
+  it('should handle a circular reference inside a nested array', () => {
+    const arr = [1, [2, 3]]
+    arr[1].push(arr)
+    expect(stringify(arr)).to.equal('[1,[2,3,"[Circular ~]"]]')
+  })
+})
