wiki-plugin-allyabase 0.0.2 → 0.0.3

package/test/node_modules/ethereum-cryptography/secp256k1-compat.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrivateKeySync = createPrivateKeySync;
-exports.createPrivateKey = createPrivateKey;
-exports.privateKeyVerify = privateKeyVerify;
-exports.publicKeyCreate = publicKeyCreate;
-exports.publicKeyVerify = publicKeyVerify;
-exports.publicKeyConvert = publicKeyConvert;
-exports.ecdsaSign = ecdsaSign;
-exports.ecdsaRecover = ecdsaRecover;
-exports.ecdsaVerify = ecdsaVerify;
-exports.privateKeyTweakAdd = privateKeyTweakAdd;
-exports.privateKeyNegate = privateKeyNegate;
-exports.publicKeyNegate = publicKeyNegate;
-exports.publicKeyCombine = publicKeyCombine;
-exports.publicKeyTweakAdd = publicKeyTweakAdd;
-exports.publicKeyTweakMul = publicKeyTweakMul;
-exports.privateKeyTweakMul = privateKeyTweakMul;
-exports.signatureExport = signatureExport;
-exports.signatureImport = signatureImport;
-exports.signatureNormalize = signatureNormalize;
-exports.ecdh = ecdh;
-exports.contextRandomize = contextRandomize;
-const sha256_1 = require("@noble/hashes/sha256");
-const modular_1 = require("@noble/curves/abstract/modular");
-const secp256k1_js_1 = require("./secp256k1.js");
-const utils_js_1 = require("./utils.js");
-// Use `secp256k1` module directly.
-// This is a legacy compatibility layer for the npm package `secp256k1` via noble-secp256k1
-const Point = secp256k1_js_1.secp256k1.ProjectivePoint;
-function hexToNumber(hex) {
-    if (typeof hex !== "string") {
-        throw new TypeError("hexToNumber: expected string, got " + typeof hex);
-    }
-    return BigInt(`0x${hex}`);
-}
-// Copy-paste from secp256k1, maybe export it?
-const bytesToNumber = (bytes) => hexToNumber((0, utils_js_1.toHex)(bytes));
-const numberToHex = (num) => num.toString(16).padStart(64, "0");
-const numberToBytes = (num) => (0, utils_js_1.hexToBytes)(numberToHex(num));
-const ORDER = secp256k1_js_1.secp256k1.CURVE.n;
-function output(out = (len) => new Uint8Array(len), length, value) {
-    if (typeof out === "function") {
-        out = out(length);
-    }
-    (0, utils_js_1.assertBytes)(out, length);
-    if (value) {
-        out.set(value);
-    }
-    return out;
-}
-function getSignature(signature) {
-    (0, utils_js_1.assertBytes)(signature, 64);
-    return secp256k1_js_1.secp256k1.Signature.fromCompact(signature);
-}
-function createPrivateKeySync() {
-    return secp256k1_js_1.secp256k1.utils.randomPrivateKey();
-}
-async function createPrivateKey() {
-    return createPrivateKeySync();
-}
-function privateKeyVerify(privateKey) {
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    return secp256k1_js_1.secp256k1.utils.isValidPrivateKey(privateKey);
-}
-function publicKeyCreate(privateKey, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    (0, utils_js_1.assertBool)(compressed);
-    const res = secp256k1_js_1.secp256k1.getPublicKey(privateKey, compressed);
-    return output(out, compressed ? 33 : 65, res);
-}
-function publicKeyVerify(publicKey) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    try {
-        Point.fromHex(publicKey);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}
-function publicKeyConvert(publicKey, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBool)(compressed);
-    const res = Point.fromHex(publicKey).toRawBytes(compressed);
-    return output(out, compressed ? 33 : 65, res);
-}
-function ecdsaSign(msgHash, privateKey, options = { noncefn: undefined, data: undefined }, out) {
-    (0, utils_js_1.assertBytes)(msgHash, 32);
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    if (typeof options !== "object" || options === null) {
-        throw new TypeError("secp256k1.ecdsaSign: options should be object");
-    }
-    // noble-secp256k1 uses hmac instead of hmac-drbg here
-    if (options &&
-        (options.noncefn !== undefined || options.data !== undefined)) {
-        throw new Error("Secp256k1: noncefn && data is unsupported");
-    }
-    const sig = secp256k1_js_1.secp256k1.sign(msgHash, privateKey);
-    const recid = sig.recovery;
-    return { signature: output(out, 64, sig.toCompactRawBytes()), recid };
-}
-function ecdsaRecover(signature, recid, msgHash, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(msgHash, 32);
-    (0, utils_js_1.assertBool)(compressed);
-    const sign = getSignature(signature);
-    const point = sign.addRecoveryBit(recid).recoverPublicKey(msgHash);
-    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
-}
-function ecdsaVerify(signature, msgHash, publicKey) {
-    (0, utils_js_1.assertBytes)(signature, 64);
-    (0, utils_js_1.assertBytes)(msgHash, 32);
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBytes)(signature, 64);
-    const r = bytesToNumber(signature.slice(0, 32));
-    const s = bytesToNumber(signature.slice(32, 64));
-    if (r >= ORDER || s >= ORDER) {
-        throw new Error("Cannot parse signature");
-    }
-    const pub = Point.fromHex(publicKey); // can throw error
-    pub; // typescript
-    let sig;
-    try {
-        sig = getSignature(signature);
-    }
-    catch (error) {
-        return false;
-    }
-    return secp256k1_js_1.secp256k1.verify(sig, msgHash, publicKey);
-}
-function privateKeyTweakAdd(privateKey, tweak) {
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    (0, utils_js_1.assertBytes)(tweak, 32);
-    let t = bytesToNumber(tweak);
-    if (t === 0n) {
-        throw new Error("Tweak must not be zero");
-    }
-    if (t >= ORDER) {
-        throw new Error("Tweak bigger than curve order");
-    }
-    t += bytesToNumber(privateKey);
-    if (t >= ORDER) {
-        t -= ORDER;
-    }
-    if (t === 0n) {
-        throw new Error("The tweak was out of range or the resulted private key is invalid");
-    }
-    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(t)));
-    return privateKey;
-}
-function privateKeyNegate(privateKey) {
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    const bn = (0, modular_1.mod)(-bytesToNumber(privateKey), ORDER);
-    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(bn)));
-    return privateKey;
-}
-function publicKeyNegate(publicKey, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBool)(compressed);
-    const point = Point.fromHex(publicKey).negate();
-    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
-}
-function publicKeyCombine(publicKeys, compressed = true, out) {
-    if (!Array.isArray(publicKeys) || !publicKeys.length) {
-        throw new TypeError(`Expected array with one or more items, not ${publicKeys}`);
-    }
-    for (const publicKey of publicKeys) {
-        (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    }
-    (0, utils_js_1.assertBool)(compressed);
-    const combined = publicKeys
-        .map((pub) => Point.fromHex(pub))
-        .reduce((res, curr) => res.add(curr), Point.ZERO);
-    // Prohibit returning ZERO point
-    if (combined.equals(Point.ZERO)) {
-        throw new Error("Combined result must not be zero");
-    }
-    return output(out, compressed ? 33 : 65, combined.toRawBytes(compressed));
-}
-function publicKeyTweakAdd(publicKey, tweak, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBytes)(tweak, 32);
-    (0, utils_js_1.assertBool)(compressed);
-    const p1 = Point.fromHex(publicKey);
-    const p2 = Point.fromPrivateKey(tweak);
-    const point = p1.add(p2);
-    if (p2.equals(Point.ZERO) || point.equals(Point.ZERO)) {
-        throw new Error("Tweak must not be zero");
-    }
-    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
-}
-function publicKeyTweakMul(publicKey, tweak, compressed = true, out) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBytes)(tweak, 32);
-    (0, utils_js_1.assertBool)(compressed);
-    const bn = bytesToNumber(tweak);
-    if (bn === 0n) {
-        throw new Error("Tweak must not be zero");
-    }
-    if (bn <= 1 || bn >= ORDER) {
-        throw new Error("Tweak is zero or bigger than curve order");
-    }
-    const point = Point.fromHex(publicKey).multiply(bn);
-    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
-}
-function privateKeyTweakMul(privateKey, tweak) {
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    (0, utils_js_1.assertBytes)(tweak, 32);
-    const bn = bytesToNumber(tweak);
-    if (bn <= 1 || bn >= ORDER) {
-        throw new Error("Tweak is zero or bigger than curve order");
-    }
-    const res = (0, modular_1.mod)(bn * bytesToNumber(privateKey), ORDER);
-    if (res === 0n) {
-        throw new Error("The tweak was out of range or the resulted private key is invalid");
-    }
-    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(res)));
-    return privateKey;
-}
-// internal -> DER
-function signatureExport(signature, out) {
-    const res = getSignature(signature).toDERRawBytes();
-    return output(out, 72, res.slice()).slice(0, res.length);
-}
-// DER -> internal
-function signatureImport(signature, out) {
-    (0, utils_js_1.assertBytes)(signature);
-    const sig = secp256k1_js_1.secp256k1.Signature.fromDER(signature);
-    return output(out, 64, (0, utils_js_1.hexToBytes)(sig.toCompactHex()));
-}
-function signatureNormalize(signature) {
-    const res = getSignature(signature);
-    if (res.s > ORDER / 2n) {
-        signature.set(numberToBytes(ORDER - res.s), 32);
-    }
-    return signature;
-}
-function ecdh(publicKey, privateKey, options = {}, out) {
-    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
-    (0, utils_js_1.assertBytes)(privateKey, 32);
-    if (typeof options !== "object" || options === null) {
-        throw new TypeError("secp256k1.ecdh: options should be object");
-    }
-    if (options.data !== undefined) {
-        (0, utils_js_1.assertBytes)(options.data);
-    }
-    const point = Point.fromHex(secp256k1_js_1.secp256k1.getSharedSecret(privateKey, publicKey));
-    if (options.hashfn === undefined) {
-        return output(out, 32, (0, sha256_1.sha256)(point.toRawBytes(true)));
-    }
-    if (typeof options.hashfn !== "function") {
-        throw new TypeError("secp256k1.ecdh: options.hashfn should be function");
-    }
-    if (options.xbuf !== undefined) {
-        (0, utils_js_1.assertBytes)(options.xbuf, 32);
-    }
-    if (options.ybuf !== undefined) {
-        (0, utils_js_1.assertBytes)(options.ybuf, 32);
-    }
-    (0, utils_js_1.assertBytes)(out, 32);
-    const { x, y } = point.toAffine();
-    const xbuf = options.xbuf || new Uint8Array(32);
-    xbuf.set(numberToBytes(x));
-    const ybuf = options.ybuf || new Uint8Array(32);
-    ybuf.set(numberToBytes(y));
-    const hash = options.hashfn(xbuf, ybuf, options.data);
-    if (!(hash instanceof Uint8Array) || hash.length !== 32) {
-        throw new Error("secp256k1.ecdh: invalid options.hashfn output");
-    }
-    return output(out, 32, hash);
-}
-function contextRandomize(seed) {
-    if (seed !== null) {
-        (0, utils_js_1.assertBytes)(seed, 32);
-    }
-    // There is no context to randomize
-}

package/test/node_modules/ethereum-cryptography/secp256k1.d.ts

@@ -1 +0,0 @@
-export { secp256k1 } from "@noble/curves/secp256k1";

package/test/node_modules/ethereum-cryptography/secp256k1.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.secp256k1 = void 0;
-var secp256k1_1 = require("@noble/curves/secp256k1");
-Object.defineProperty(exports, "secp256k1", { enumerable: true, get: function () { return secp256k1_1.secp256k1; } });

package/test/node_modules/ethereum-cryptography/sha256.d.ts

@@ -1 +0,0 @@
-export declare const sha256: (msg: Uint8Array) => Uint8Array;

package/test/node_modules/ethereum-cryptography/sha256.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256 = void 0;
-const sha256_1 = require("@noble/hashes/sha256");
-const utils_js_1 = require("./utils.js");
-exports.sha256 = (0, utils_js_1.wrapHash)(sha256_1.sha256);

package/test/node_modules/ethereum-cryptography/sha512.d.ts

@@ -1 +0,0 @@
-export declare const sha512: (msg: Uint8Array) => Uint8Array;

package/test/node_modules/ethereum-cryptography/sha512.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha512 = void 0;
-const sha512_1 = require("@noble/hashes/sha512");
-const utils_js_1 = require("./utils.js");
-exports.sha512 = (0, utils_js_1.wrapHash)(sha512_1.sha512);

package/test/node_modules/ethereum-cryptography/utils.d.ts

@@ -1,12 +0,0 @@
-declare const assertBool: typeof import("@noble/hashes/_assert").bool;
-declare const assertBytes: typeof import("@noble/hashes/_assert").bytes;
-export { assertBool, assertBytes };
-export { bytesToHex, bytesToHex as toHex, concatBytes, createView, utf8ToBytes } from "@noble/hashes/utils";
-export declare function bytesToUtf8(data: Uint8Array): string;
-export declare function hexToBytes(data: string): Uint8Array;
-export declare function equalsBytes(a: Uint8Array, b: Uint8Array): boolean;
-export declare function wrapHash(hash: (msg: Uint8Array) => Uint8Array): (msg: Uint8Array) => Uint8Array;
-export declare const crypto: {
-    node?: any;
-    web?: any;
-};

package/test/node_modules/ethereum-cryptography/utils.js

@@ -1,63 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.crypto = exports.utf8ToBytes = exports.createView = exports.concatBytes = exports.toHex = exports.bytesToHex = exports.assertBytes = exports.assertBool = void 0;
-exports.bytesToUtf8 = bytesToUtf8;
-exports.hexToBytes = hexToBytes;
-exports.equalsBytes = equalsBytes;
-exports.wrapHash = wrapHash;
-const _assert_1 = __importDefault(require("@noble/hashes/_assert"));
-const utils_1 = require("@noble/hashes/utils");
-const assertBool = _assert_1.default.bool;
-exports.assertBool = assertBool;
-const assertBytes = _assert_1.default.bytes;
-exports.assertBytes = assertBytes;
-var utils_2 = require("@noble/hashes/utils");
-Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
-Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
-Object.defineProperty(exports, "concatBytes", { enumerable: true, get: function () { return utils_2.concatBytes; } });
-Object.defineProperty(exports, "createView", { enumerable: true, get: function () { return utils_2.createView; } });
-Object.defineProperty(exports, "utf8ToBytes", { enumerable: true, get: function () { return utils_2.utf8ToBytes; } });
-// buf.toString('utf8') -> bytesToUtf8(buf)
-function bytesToUtf8(data) {
-    if (!(data instanceof Uint8Array)) {
-        throw new TypeError(`bytesToUtf8 expected Uint8Array, got ${typeof data}`);
-    }
-    return new TextDecoder().decode(data);
-}
-function hexToBytes(data) {
-    const sliced = data.startsWith("0x") ? data.substring(2) : data;
-    return (0, utils_1.hexToBytes)(sliced);
-}
-// buf.equals(buf2) -> equalsBytes(buf, buf2)
-function equalsBytes(a, b) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-// Internal utils
-function wrapHash(hash) {
-    return (msg) => {
-        _assert_1.default.bytes(msg);
-        return hash(msg);
-    };
-}
-// TODO(v3): switch away from node crypto, remove this unnecessary variable.
-exports.crypto = (() => {
-    const webCrypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : undefined;
-    const nodeRequire = typeof module !== "undefined" &&
-        typeof module.require === "function" &&
-        module.require.bind(module);
-    return {
-        node: nodeRequire && !webCrypto ? nodeRequire("crypto") : undefined,
-        web: webCrypto
-    };
-})();

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

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

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

@@ -1,17 +0,0 @@
-# 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/test/node_modules/fast-safe-stringify/LICENSE

@@ -1,23 +0,0 @@
-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/test/node_modules/fast-safe-stringify/benchmark.js

@@ -1,137 +0,0 @@
-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/test/node_modules/fast-safe-stringify/index.d.ts

@@ -1,23 +0,0 @@
-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;