fast-is-equal 1.0.4 → 1.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 Jairaj Jangle
+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/README.md

@@ -1,8 +1,8 @@
 # fast-is-equal
 
-Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash’s `isEqual` - because speed matters.
+⚡️Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash's `isEqual` - because speed matters.
 
-[![npm version](https://img.shields.io/npm/v/fast-is-equal)](https://badge.fury.io/js/fast-is-equal)
+[![npm version](https://img.shields.io/npm/v/fast-is-equal)](https://badge.fury.io/js/fast-is-equal) [![License](https://img.shields.io/github/license/JairajJangle/fast-is-equal)](https://github.com/JairajJangle/fast-is-equal/blob/main/LICENSE) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/fast-is-equal)
 
 ## Installation
 
@@ -19,6 +19,7 @@ npm install fast-is-equal
 ```
 
 ## Usage
+
 ```typescript
 import { fastIsEqual } from 'fast-is-equal';
 
@@ -28,152 +29,47 @@ console.log(fastIsEqual([1, 2], [1, 3])); // false
 ```
 
 ## Features
+
 - Lightweight and dependency-free.
 - Handles primitives, objects, arrays, Maps, Sets, circular references, and more.
 - Optimized for performance (see benchmarks).
 
 ## Benchmarks
-`fast-is-equal` outperforms Lodash’s `isEqual` in most cases. Run `npm run benchmark` locally to compare:
-```bash
-Performance Comparison: fastIsEqual vs Lodash isEqual
-Iterations per test case: 1000000
-----------------------------------------
-Test Case 1: Numbers
-  fastIsEqual: 0.000003 ms
-  Lodash isEqual: 0.000006 ms
-  Difference (fastIsEqual - Lodash): -0.000002 ms
-  fastIsEqual is 1.62x faster than Lodash
-----------------------------------------
-Test Case 2: Strings
-  fastIsEqual: 0.000005 ms
-  Lodash isEqual: 0.000005 ms
-  Difference (fastIsEqual - Lodash): -0.000000 ms
-  fastIsEqual is 1.08x faster than Lodash
-----------------------------------------
-Test Case 3: Booleans
-  fastIsEqual: 0.000005 ms
-  Lodash isEqual: 0.000005 ms
-  Difference (fastIsEqual - Lodash): -0.000000 ms
-  fastIsEqual is 1.06x faster than Lodash
-----------------------------------------
-Test Case 4: NaN
-  fastIsEqual: 0.000006 ms
-  Lodash isEqual: 0.000012 ms
-  Difference (fastIsEqual - Lodash): -0.000006 ms
-  fastIsEqual is 1.98x faster than Lodash
-----------------------------------------
-Test Case 5: Simple Object (equal)
-  fastIsEqual: 0.000097 ms
-  Lodash isEqual: 0.000271 ms
-  Difference (fastIsEqual - Lodash): -0.000174 ms
-  fastIsEqual is 2.80x faster than Lodash
-----------------------------------------
-Test Case 6: Simple Object (unequal)
-  fastIsEqual: 0.000105 ms
-  Lodash isEqual: 0.000271 ms
-  Difference (fastIsEqual - Lodash): -0.000165 ms
-  fastIsEqual is 2.57x faster than Lodash
-----------------------------------------
-Test Case 7: Nested Object (equal)
-  fastIsEqual: 0.000184 ms
-  Lodash isEqual: 0.000835 ms
-  Difference (fastIsEqual - Lodash): -0.000651 ms
-  fastIsEqual is 4.53x faster than Lodash
-----------------------------------------
-Test Case 8: Nested Object (unequal)
-  fastIsEqual: 0.000197 ms
-  Lodash isEqual: 0.000850 ms
-  Difference (fastIsEqual - Lodash): -0.000653 ms
-  fastIsEqual is 4.31x faster than Lodash
-----------------------------------------
-Test Case 9: Array of Primitives (equal)
-  fastIsEqual: 0.000017 ms
-  Lodash isEqual: 0.000102 ms
-  Difference (fastIsEqual - Lodash): -0.000085 ms
-  fastIsEqual is 5.95x faster than Lodash
-----------------------------------------
-Test Case 10: Array of Primitives (unequal)
-  fastIsEqual: 0.000015 ms
-  Lodash isEqual: 0.000103 ms
-  Difference (fastIsEqual - Lodash): -0.000088 ms
-  fastIsEqual is 6.79x faster than Lodash
-----------------------------------------
-Test Case 11: Array of Objects (equal)
-  fastIsEqual: 0.000078 ms
-  Lodash isEqual: 0.000638 ms
-  Difference (fastIsEqual - Lodash): -0.000560 ms
-  fastIsEqual is 8.15x faster than Lodash
-----------------------------------------
-Test Case 12: Circular Reference
-  fastIsEqual: 0.000095 ms
-  Lodash isEqual: 0.000493 ms
-  Difference (fastIsEqual - Lodash): -0.000399 ms
-  fastIsEqual is 5.22x faster than Lodash
-----------------------------------------
-Test Case 13: Map (equal)
-  fastIsEqual: 0.000074 ms
-  Lodash isEqual: 0.001383 ms
-  Difference (fastIsEqual - Lodash): -0.001309 ms
-  fastIsEqual is 18.67x faster than Lodash
-----------------------------------------
-Test Case 14: Map (unequal)
-  fastIsEqual: 0.000076 ms
-  Lodash isEqual: 0.001330 ms
-  Difference (fastIsEqual - Lodash): -0.001255 ms
-  fastIsEqual is 17.59x faster than Lodash
-----------------------------------------
-Test Case 15: Set (equal)
-  fastIsEqual: 0.000073 ms
-  Lodash isEqual: 0.000949 ms
-  Difference (fastIsEqual - Lodash): -0.000876 ms
-  fastIsEqual is 13.07x faster than Lodash
-----------------------------------------
-Test Case 16: Set (unequal)
-  fastIsEqual: 0.000070 ms
-  Lodash isEqual: 0.000930 ms
-  Difference (fastIsEqual - Lodash): -0.000860 ms
-  fastIsEqual is 13.22x faster than Lodash
-----------------------------------------
-Test Case 17: Empty Object vs Array
-  fastIsEqual: 0.000009 ms
-  Lodash isEqual: 0.000043 ms
-  Difference (fastIsEqual - Lodash): -0.000034 ms
-  fastIsEqual is 4.74x faster than Lodash
-----------------------------------------
-Test Case 18: Map vs Set
-  fastIsEqual: 0.000018 ms
-  Lodash isEqual: 0.000469 ms
-  Difference (fastIsEqual - Lodash): -0.000452 ms
-  fastIsEqual is 26.55x faster than Lodash
-----------------------------------------
-Average Performance:
-  fastIsEqual: 0.000063 ms
-  Lodash isEqual: 0.000483 ms
-  fastIsEqual is on average 7.71x faster than Lodash
-```
+
+`fast-is-equal` outperforms Lodash's `isEqual` in most cases. Run `npm run benchmark` locally to compare:
+
+| Test Case | fastIsEqual (ms) | Lodash isEqual (ms) | Performance Gain |
+|-----------|------------------|---------------------|------------------|
+| Numbers | 0.000003 | 0.000007 | **2.56x faster** |
+| Strings | 0.000008 | 0.000007 | 0.92x slower |
+| Booleans | 0.000007 | 0.000007 | **0.95x faster** |
+| NaN | 0.000008 | 0.000017 | **2.05x faster** |
+| Simple Object (equal) | 0.000137 | 0.000531 | **3.87x faster** |
+| Simple Object (unequal) | 0.000137 | 0.000560 | **4.09x faster** |
+| Nested Object (equal) | 0.000240 | 0.001426 | **5.95x faster** |
+| Nested Object (unequal) | 0.000242 | 0.001437 | **5.93x faster** |
+| Array of Primitives (equal) | 0.000025 | 0.000163 | **6.44x faster** |
+| Array of Primitives (unequal) | 0.000025 | 0.000170 | **6.82x faster** |
+| Array of Objects (equal) | 0.000119 | 0.001237 | **10.39x faster** |
+| Circular Reference | 0.000136 | 0.000928 | **6.83x faster** |
+| Map (equal) | 0.000101 | 0.001765 | **17.55x faster** |
+| Map (unequal) | 0.000098 | 0.001688 | **17.22x faster** |
+| Set (equal) | 0.000098 | 0.001474 | **15.04x faster** |
+| Set (unequal) | 0.000101 | 0.001765 | **17.55x faster** |
+| Empty Object vs Array | 0.000015 | 0.000051 | **3.51x faster** |
+| Map vs Set | 0.000026 | 0.000811 | **30.69x faster** |
+
+[Benchmark logs](benchmarks/results.txt)
+
+### Summary
+- **Average Performance**: `fastIsEqual` is **10.58x faster** than Lodash's `isEqual`
+- **Best Performance**: Map vs Set comparison shows **30.69x faster** execution
+- **Iterations**: 1,000,000 per test case for accurate measurements
 
 ## License
+
 MIT
-```
-MIT License
-
-Copyright (c) 2025 Jairaj Jangle
-
-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.
-```
+
+## 🙏 Support the project
+
+<p align="center" valign="center">   <a href="https://liberapay.com/FutureJJ/donate">     <img src="https://liberapay.com/assets/widgets/donate.svg" alt="LiberPay_Donation_Button" height="50" >    </a>   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;   <a href=".github/assets/Jairaj_Jangle_Google_Pay_UPI_QR_Code.jpg">     <img src=".github/assets/upi.png" alt="Paypal_Donation_Button" height="50" >   </a>   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;   <a href="https://www.paypal.com/paypalme/jairajjangle001/usd">     <img src=".github/assets/paypal_donate.png" alt="Paypal_Donation_Button" height="50" >   </a> </p>

package/dist/__tests__/fastIsEqual.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("../index");
-describe('fastIsEqual', () => {
+describe('isEqual', () => {
     // **Primitives**
     it('should return true for identical primitives', () => {
         expect((0, index_1.fastIsEqual)(1, 1)).toBe(true);
@@ -37,21 +37,6 @@ describe('fastIsEqual', () => {
         const obj2 = { a: 1, b: { c: 2 } };
         expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
     });
-    it('should return true for deeply unequal objects', () => {
-        const obj1 = { a: 1, b: { c: 2 } };
-        const obj2 = { a: 1, b: { c: 3 } };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
-    });
-    it('should return true for deeply equal objects with array', () => {
-        const obj1 = { a: 1, b: { c: [1, 2, 3] } };
-        const obj2 = { a: 1, b: { c: [1, 2, 3] } };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
-    });
-    it('should return true for deeply unequal objects with array', () => {
-        const obj1 = { a: 1, b: { c: [1, 2, 3] } };
-        const obj2 = { a: 1, b: { c: [1, 2, 3, 4] } };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
-    });
     it('should return false for objects with different keys', () => {
         const obj1 = { a: 1 };
         const obj2 = { b: 1 };
@@ -82,11 +67,6 @@ describe('fastIsEqual', () => {
         const arr2 = [1, 3];
         expect((0, index_1.fastIsEqual)(arr1, arr2)).toBe(false);
     });
-    it('should return true for arrays with different order', () => {
-        const arr1 = [1, 2, 3, 4];
-        const arr2 = [1, 2, 4, 3];
-        expect((0, index_1.fastIsEqual)(arr1, arr2)).toBe(false);
-    });
     // **Dates**
     it('should return true for identical dates', () => {
         const date = new Date();
@@ -197,137 +177,4 @@ describe('fastIsEqual', () => {
         expect((0, index_1.fastIsEqual)({}, [])).toBe(false);
         expect((0, index_1.fastIsEqual)(new Map(), new Set())).toBe(false);
     });
-    // **Symbol Tests**
-    it('should return true for identical symbols', () => {
-        const sym = Symbol('test');
-        expect((0, index_1.fastIsEqual)(sym, sym)).toBe(true);
-    });
-    it('should return false for different symbols with same description', () => {
-        expect((0, index_1.fastIsEqual)(Symbol('test'), Symbol('test'))).toBe(false);
-    });
-    // **BigInt Tests**
-    it('should return true for identical BigInts', () => {
-        expect((0, index_1.fastIsEqual)(BigInt(123), BigInt(123))).toBe(true);
-    });
-    it('should return false for different BigInts', () => {
-        expect((0, index_1.fastIsEqual)(BigInt(123), BigInt(456))).toBe(false);
-    });
-    // **Nested Complex Structures**
-    it('should handle deeply nested objects with arrays, maps and sets', () => {
-        const obj1 = {
-            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }],
-            d: new Set([new Map([['e', { f: 7 }]])])
-        };
-        const obj2 = {
-            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }],
-            d: new Set([new Map([['e', { f: 7 }]])])
-        };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
-    });
-    it('should detect differences in deeply nested structures', () => {
-        const obj1 = {
-            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }]
-        };
-        const obj2 = {
-            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 4 }])]]) }]
-        };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
-    });
-    // **Typed Arrays**
-    it('should compare typed arrays correctly', () => {
-        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true);
-        expect((0, index_1.fastIsEqual)(new Int32Array([1, 2, 3]), new Int32Array([1, 2, 3]))).toBe(true);
-        expect((0, index_1.fastIsEqual)(new Float64Array([1.1, 2.2]), new Float64Array([1.1, 2.2]))).toBe(true);
-        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))).toBe(false);
-        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2]), new Int8Array([1, 2]))).toBe(false);
-    });
-    // **Partial Object Comparison with Extra Keys**
-    it('should detect when objects have extra keys', () => {
-        const obj1 = { a: 1, b: 2 };
-        const obj2 = { a: 1, b: 2, c: 3 };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
-    });
-    // **Object with Different Property Orders**
-    it('should return true for objects with same properties in different order', () => {
-        const obj1 = { a: 1, b: 2, c: 3 };
-        const obj2 = { c: 3, a: 1, b: 2 };
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
-    });
-    // **Map/Set with Object Keys/Values**
-    it('should handle Maps with object keys correctly', () => {
-        const key1 = { id: 1 };
-        const key2 = { id: 1 };
-        const map1 = new Map([[key1, 'value']]);
-        const map2 = new Map([[key2, 'value']]);
-        // Objects as keys are compared by reference
-        expect((0, index_1.fastIsEqual)(map1, map2)).toBe(false);
-        // Same reference should work
-        const map3 = new Map([[key1, 'value']]);
-        expect((0, index_1.fastIsEqual)(map1, map3)).toBe(true);
-    });
-    // **WeakMap and WeakSet** (if supported by fastIsEqual)
-    it('should return true for identical WeakMap/WeakSet references', () => {
-        const weakMap = new WeakMap();
-        const weakSet = new WeakSet();
-        expect((0, index_1.fastIsEqual)(weakMap, weakMap)).toBe(true);
-        expect((0, index_1.fastIsEqual)(weakSet, weakSet)).toBe(true);
-    });
-    it('should return false for different WeakMap/WeakSet instances', () => {
-        expect((0, index_1.fastIsEqual)(new WeakMap(), new WeakMap())).toBe(false);
-        expect((0, index_1.fastIsEqual)(new WeakSet(), new WeakSet())).toBe(false);
-    });
-    // **Cross-circular References**
-    it('should handle cross-circular references', () => {
-        const obj1 = { name: 'object1' };
-        const obj2 = { name: 'object2' };
-        obj1.ref = obj2;
-        obj2.ref = obj1;
-        const obj3 = { name: 'object1' };
-        const obj4 = { name: 'object2' };
-        obj3.ref = obj4;
-        obj4.ref = obj3;
-        expect((0, index_1.fastIsEqual)(obj1, obj3)).toBe(true);
-    });
-    it('should detect differences in cross-circular references', () => {
-        const obj1 = { name: 'object1' };
-        const obj2 = { name: 'object2' };
-        obj1.ref = obj2;
-        obj2.ref = obj1;
-        const obj3 = { name: 'object1' };
-        const obj4 = { name: 'differentName' };
-        obj3.ref = obj4;
-        obj4.ref = obj3;
-        expect((0, index_1.fastIsEqual)(obj1, obj3)).toBe(false);
-    });
-    // **Edge Cases**
-    it('should handle -0 and +0 comparison', () => {
-        expect((0, index_1.fastIsEqual)(0, -0)).toBe(true); // Depending on implementation
-    });
-    it('should handle Object.create(null)', () => {
-        const obj1 = Object.create(null);
-        obj1.a = 1;
-        const obj2 = Object.create(null);
-        obj2.a = 1;
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
-    });
-    // **Performance Stress Test**
-    it('should handle large objects without stack overflow', () => {
-        // Create a very deep object
-        let obj1 = {};
-        let obj2 = {};
-        let temp1 = obj1;
-        let temp2 = obj2;
-        for (let i = 0; i < 1000; i++) {
-            temp1.next = {};
-            temp2.next = {};
-            temp1 = temp1.next;
-            temp2 = temp2.next;
-            temp1.value = i;
-            temp2.value = i;
-        }
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
-        // Change a value deep in the structure
-        temp2.value = 'different';
-        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
-    });
 });

package/dist/index.js

@@ -52,13 +52,6 @@ function deepEqual(valA, valB, visited) {
         return valA === valB;
     if (typeof valA !== typeof valB)
         return false;
-    // Handle WeakMap and WeakSet (reference equality)
-    if (valA instanceof WeakMap && valB instanceof WeakMap) {
-        return valA === valB;
-    }
-    if (valA instanceof WeakSet && valB instanceof WeakSet) {
-        return valA === valB;
-    }
     // Handle Dates
     if (valA instanceof Date && valB instanceof Date) {
         return valA.getTime() === valB.getTime();
@@ -103,23 +96,12 @@ function deepEqual(valA, valB, visited) {
         }
         return true;
     }
-    // Handle Sets with deep equality
+    // Handle Sets
     if (valA instanceof Set && valB instanceof Set) {
         if (valA.size !== valB.size)
             return false;
-        const arrA = Array.from(valA);
-        const arrB = Array.from(valB);
-        const matched = new Set();
-        for (const elemA of arrA) {
-            let found = false;
-            for (const elemB of arrB) {
-                if (!matched.has(elemB) && deepEqual(elemA, elemB, visited)) {
-                    matched.add(elemB);
-                    found = true;
-                    break;
-                }
-            }
-            if (!found)
+        for (const value of valA) {
+            if (!valB.has(value))
                 return false;
         }
         return true;

package/package.json

@@ -1,13 +1,36 @@
 {
   "name": "fast-is-equal",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash's isEqual—because speed matters.",
   "keywords": [
+    "deep-equal",
+    "equality",
+    "compare",
     "lodash",
     "isEqual",
+    "fast",
+    "performance",
     "typescript",
+    "javascript",
     "react",
-    "react-native"
+    "react-native",
+    "vue",
+    "angular",
+    "object-comparison",
+    "array-comparison",
+    "deep-comparison",
+    "utility",
+    "lightweight",
+    "zero-dependencies",
+    "circular-references",
+    "map",
+    "set",
+    "immutable",
+    "benchmark",
+    "speed",
+    "efficient",
+    "alternative",
+    "replacement"
   ],
   "homepage": "https://github.com/JairajJangle/fast-is-equal#readme",
   "bugs": {
@@ -19,6 +42,10 @@
   },
   "license": "MIT",
   "author": "Jairaj Jangle <reachout.jairaj.jangle@gmail.com> (https://github.com/JairajJangle)",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -31,11 +58,16 @@
     "dist"
   ],
   "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^10.1.7",
+    "@semantic-release/npm": "^12.0.1",
     "@types/jest": "^29.5.3",
     "@types/lodash": "^4.17.16",
     "jest": "^29.7.0",
     "lodash": "^4.17.21",
     "rimraf": "^6.0.1",
+    "semantic-release": "^24.1.0",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",