@flemist/test-variants 1.0.7 → 2.0.0

package/dist/lib/test-variants/testVariantsRun.cjs

@@ -0,0 +1,235 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var abortControllerFast = require('@flemist/abort-controller-fast');
+var asyncUtils = require('@flemist/async-utils');
+var timeLimits = require('@flemist/time-limits');
+var garbageCollect_garbageCollect = require('../garbage-collect/garbageCollect.cjs');
+var testVariants_saveErrorVariants = require('./saveErrorVariants.cjs');
+var path = require('path');
+require('fs');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+function testVariantsRun(testRun, variants, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const saveErrorVariants = options.saveErrorVariants;
+        const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
+        const sessionDate = new Date();
+        const errorVariantFilePath = saveErrorVariants
+            ? path__namespace.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : testVariants_saveErrorVariants.generateErrorVariantFilePath({ sessionDate }))
+            : null;
+        // Replay phase: run previously saved error variants before normal iteration
+        if (saveErrorVariants) {
+            const files = yield testVariants_saveErrorVariants.readErrorVariantFiles(saveErrorVariants.dir);
+            for (const filePath of files) {
+                const args = yield testVariants_saveErrorVariants.parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
+                for (let retry = 0; retry < retriesPerVariant; retry++) {
+                    const promiseOrResult = testRun(args, -1, null);
+                    if (asyncUtils.isPromiseLike(promiseOrResult)) {
+                        yield promiseOrResult;
+                    }
+                }
+            }
+        }
+        const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
+        const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
+        const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
+        const logInterval = (_g = options.logInterval) !== null && _g !== void 0 ? _g : 5000;
+        const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
+        const abortSignalExternal = options.abortSignal;
+        const findBestError = options.findBestError;
+        const parallel = options.parallel === true
+            ? Math.pow(2, 31)
+            : !options.parallel || options.parallel <= 0
+                ? 1
+                : options.parallel;
+        const seedsIterator = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _j !== void 0 ? _j : null;
+        let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
+        let bestError = null;
+        let index = -1;
+        let args = {};
+        let variantsIterator = variants[Symbol.iterator]();
+        function nextVariant() {
+            while (true) {
+                index++;
+                if (seedResult && seedResult.done) {
+                    return false;
+                }
+                if (bestError == null || index < bestError.index) {
+                    const result = variantsIterator.next();
+                    if (!result.done) {
+                        args = result.value;
+                        return true;
+                    }
+                }
+                if (!seedsIterator) {
+                    return false;
+                }
+                seedResult = seedsIterator.next();
+                if (seedResult.done) {
+                    return false;
+                }
+                index = -1;
+                variantsIterator = variants[Symbol.iterator]();
+            }
+        }
+        const abortControllerParallel = new abortControllerFast.AbortControllerFast();
+        const abortSignalParallel = asyncUtils.combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
+        const abortSignalAll = abortSignalParallel;
+        let debug = false;
+        let iterations = 0;
+        let iterationsAsync = 0;
+        let prevLogTime = Date.now();
+        let prevGC_Time = prevLogTime;
+        let prevGC_Iterations = iterations;
+        let prevGC_IterationsAsync = iterationsAsync;
+        const pool = parallel <= 1
+            ? null
+            : new timeLimits.Pool(parallel);
+        function onCompleted() {
+            if (logCompleted) {
+                console.log(`[test-variants] variants: ${index}, iterations: ${iterations}, async: ${iterationsAsync}`);
+            }
+        }
+        function next() {
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
+                    const _index = index;
+                    const _args = Object.assign(Object.assign({}, args), { seed: seedResult === null || seedResult === void 0 ? void 0 : seedResult.value });
+                    const now = (logInterval || GC_Interval) && Date.now();
+                    if (logInterval && now - prevLogTime >= logInterval) {
+                        // the log is required to prevent the karma browserNoActivityTimeout
+                        console.log(iterations);
+                        prevLogTime = now;
+                    }
+                    if (GC_Iterations && iterations - prevGC_Iterations >= GC_Iterations
+                        || GC_IterationsAsync && iterationsAsync - prevGC_IterationsAsync >= GC_IterationsAsync
+                        || GC_Interval && now - prevGC_Time >= GC_Interval) {
+                        prevGC_Iterations = iterations;
+                        prevGC_IterationsAsync = iterationsAsync;
+                        prevGC_Time = now;
+                        yield garbageCollect_garbageCollect.garbageCollect(1);
+                    }
+                    if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
+                        continue;
+                    }
+                    if (!pool || abortSignalParallel.aborted) {
+                        try {
+                            let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
+                            if (asyncUtils.isPromiseLike(promiseOrIterations)) {
+                                promiseOrIterations = yield promiseOrIterations;
+                            }
+                            if (!promiseOrIterations) {
+                                debug = true;
+                                abortControllerParallel.abort();
+                                continue;
+                            }
+                            const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
+                            iterationsAsync += _iterationsAsync;
+                            iterations += _iterationsSync + _iterationsAsync;
+                        }
+                        catch (err) {
+                            if (errorVariantFilePath) {
+                                yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                            }
+                            if (findBestError) {
+                                bestError = {
+                                    error: err,
+                                    args: _args,
+                                    index: _index,
+                                };
+                                debug = false;
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    else {
+                        if (!pool.hold(1)) {
+                            yield pool.holdWait(1);
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-loop-func
+                        void (() => tslib.__awaiter(this, void 0, void 0, function* () {
+                            try {
+                                if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
+                                    return;
+                                }
+                                let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
+                                if (asyncUtils.isPromiseLike(promiseOrIterations)) {
+                                    promiseOrIterations = yield promiseOrIterations;
+                                }
+                                if (!promiseOrIterations) {
+                                    debug = true;
+                                    abortControllerParallel.abort();
+                                    return;
+                                }
+                                const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
+                                iterationsAsync += _iterationsAsync;
+                                iterations += _iterationsSync + _iterationsAsync;
+                            }
+                            catch (err) {
+                                if (errorVariantFilePath) {
+                                    yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                                }
+                                if (findBestError) {
+                                    bestError = {
+                                        error: err,
+                                        args: _args,
+                                        index: _index,
+                                    };
+                                    debug = false;
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                            finally {
+                                void pool.release(1);
+                            }
+                        }))();
+                    }
+                }
+                if (pool) {
+                    yield pool.holdWait(parallel);
+                    void pool.release(parallel);
+                }
+                if (abortSignalAll === null || abortSignalAll === void 0 ? void 0 : abortSignalAll.aborted) {
+                    throw abortSignalAll.reason;
+                }
+                onCompleted();
+                yield garbageCollect_garbageCollect.garbageCollect(1);
+                return iterations;
+            });
+        }
+        const result = yield next();
+        return {
+            iterations: result,
+            bestError,
+        };
+    });
+}
+
+exports.testVariantsRun = testVariantsRun;

package/dist/lib/test-variants/testVariantsRun.d.ts

@@ -0,0 +1,33 @@
+import { TestVariantsTestRun } from './testVariantsCreateTestRun';
+import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
+import { Obj, type SaveErrorVariantsOptions } from "./types";
+export declare type TestVariantsFindBestErrorOptions = {
+    seeds: Iterable<any>;
+};
+export declare type TestVariantsRunOptions<Args extends Obj = Obj, SavedArgs = Args> = {
+    /** Wait for garbage collection after iterations */
+    GC_Iterations?: null | number;
+    /** Same as GC_Iterations but only for async test variants, required for 10000 and more of Promise rejections */
+    GC_IterationsAsync?: null | number;
+    /** Wait for garbage collection after time interval, required to prevent the karma browserDisconnectTimeout */
+    GC_Interval?: null | number;
+    /** console log current iterations, required to prevent the karma browserNoActivityTimeout */
+    logInterval?: null | number;
+    /** console log iterations on test completed */
+    logCompleted?: null | boolean;
+    abortSignal?: null | IAbortSignalFast;
+    parallel?: null | number | boolean;
+    findBestError?: null | TestVariantsFindBestErrorOptions;
+    /** Save error-causing args to files and replay them before normal iteration */
+    saveErrorVariants?: null | SaveErrorVariantsOptions<Args, SavedArgs>;
+};
+export declare type TestVariantsBestError<Args extends Obj> = {
+    error: any;
+    args: Args;
+    index: number;
+};
+export declare type TestVariantsRunResult<Arg extends Obj> = {
+    iterations: number;
+    bestError: null | TestVariantsBestError<Arg>;
+};
+export declare function testVariantsRun<Args extends Obj, SavedArgs = Args>(testRun: TestVariantsTestRun<Args>, variants: Iterable<Args>, options?: TestVariantsRunOptions<Args, SavedArgs>): Promise<TestVariantsRunResult<Args>>;

package/dist/lib/test-variants/testVariantsRun.mjs

@@ -0,0 +1,211 @@
+import { __awaiter } from 'tslib';
+import { AbortControllerFast } from '@flemist/abort-controller-fast';
+import { isPromiseLike, combineAbortSignals } from '@flemist/async-utils';
+import { Pool } from '@flemist/time-limits';
+import { garbageCollect } from '../garbage-collect/garbageCollect.mjs';
+import { generateErrorVariantFilePath, readErrorVariantFiles, parseErrorVariantFile, saveErrorVariantFile } from './saveErrorVariants.mjs';
+import * as path from 'path';
+import 'fs';
+
+function testVariantsRun(testRun, variants, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return __awaiter(this, void 0, void 0, function* () {
+        const saveErrorVariants = options.saveErrorVariants;
+        const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
+        const sessionDate = new Date();
+        const errorVariantFilePath = saveErrorVariants
+            ? path.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : generateErrorVariantFilePath({ sessionDate }))
+            : null;
+        // Replay phase: run previously saved error variants before normal iteration
+        if (saveErrorVariants) {
+            const files = yield readErrorVariantFiles(saveErrorVariants.dir);
+            for (const filePath of files) {
+                const args = yield parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
+                for (let retry = 0; retry < retriesPerVariant; retry++) {
+                    const promiseOrResult = testRun(args, -1, null);
+                    if (isPromiseLike(promiseOrResult)) {
+                        yield promiseOrResult;
+                    }
+                }
+            }
+        }
+        const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
+        const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
+        const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
+        const logInterval = (_g = options.logInterval) !== null && _g !== void 0 ? _g : 5000;
+        const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
+        const abortSignalExternal = options.abortSignal;
+        const findBestError = options.findBestError;
+        const parallel = options.parallel === true
+            ? Math.pow(2, 31)
+            : !options.parallel || options.parallel <= 0
+                ? 1
+                : options.parallel;
+        const seedsIterator = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _j !== void 0 ? _j : null;
+        let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
+        let bestError = null;
+        let index = -1;
+        let args = {};
+        let variantsIterator = variants[Symbol.iterator]();
+        function nextVariant() {
+            while (true) {
+                index++;
+                if (seedResult && seedResult.done) {
+                    return false;
+                }
+                if (bestError == null || index < bestError.index) {
+                    const result = variantsIterator.next();
+                    if (!result.done) {
+                        args = result.value;
+                        return true;
+                    }
+                }
+                if (!seedsIterator) {
+                    return false;
+                }
+                seedResult = seedsIterator.next();
+                if (seedResult.done) {
+                    return false;
+                }
+                index = -1;
+                variantsIterator = variants[Symbol.iterator]();
+            }
+        }
+        const abortControllerParallel = new AbortControllerFast();
+        const abortSignalParallel = combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
+        const abortSignalAll = abortSignalParallel;
+        let debug = false;
+        let iterations = 0;
+        let iterationsAsync = 0;
+        let prevLogTime = Date.now();
+        let prevGC_Time = prevLogTime;
+        let prevGC_Iterations = iterations;
+        let prevGC_IterationsAsync = iterationsAsync;
+        const pool = parallel <= 1
+            ? null
+            : new Pool(parallel);
+        function onCompleted() {
+            if (logCompleted) {
+                console.log(`[test-variants] variants: ${index}, iterations: ${iterations}, async: ${iterationsAsync}`);
+            }
+        }
+        function next() {
+            return __awaiter(this, void 0, void 0, function* () {
+                while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
+                    const _index = index;
+                    const _args = Object.assign(Object.assign({}, args), { seed: seedResult === null || seedResult === void 0 ? void 0 : seedResult.value });
+                    const now = (logInterval || GC_Interval) && Date.now();
+                    if (logInterval && now - prevLogTime >= logInterval) {
+                        // the log is required to prevent the karma browserNoActivityTimeout
+                        console.log(iterations);
+                        prevLogTime = now;
+                    }
+                    if (GC_Iterations && iterations - prevGC_Iterations >= GC_Iterations
+                        || GC_IterationsAsync && iterationsAsync - prevGC_IterationsAsync >= GC_IterationsAsync
+                        || GC_Interval && now - prevGC_Time >= GC_Interval) {
+                        prevGC_Iterations = iterations;
+                        prevGC_IterationsAsync = iterationsAsync;
+                        prevGC_Time = now;
+                        yield garbageCollect(1);
+                    }
+                    if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
+                        continue;
+                    }
+                    if (!pool || abortSignalParallel.aborted) {
+                        try {
+                            let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
+                            if (isPromiseLike(promiseOrIterations)) {
+                                promiseOrIterations = yield promiseOrIterations;
+                            }
+                            if (!promiseOrIterations) {
+                                debug = true;
+                                abortControllerParallel.abort();
+                                continue;
+                            }
+                            const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
+                            iterationsAsync += _iterationsAsync;
+                            iterations += _iterationsSync + _iterationsAsync;
+                        }
+                        catch (err) {
+                            if (errorVariantFilePath) {
+                                yield saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                            }
+                            if (findBestError) {
+                                bestError = {
+                                    error: err,
+                                    args: _args,
+                                    index: _index,
+                                };
+                                debug = false;
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    else {
+                        if (!pool.hold(1)) {
+                            yield pool.holdWait(1);
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-loop-func
+                        void (() => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
+                                    return;
+                                }
+                                let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
+                                if (isPromiseLike(promiseOrIterations)) {
+                                    promiseOrIterations = yield promiseOrIterations;
+                                }
+                                if (!promiseOrIterations) {
+                                    debug = true;
+                                    abortControllerParallel.abort();
+                                    return;
+                                }
+                                const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
+                                iterationsAsync += _iterationsAsync;
+                                iterations += _iterationsSync + _iterationsAsync;
+                            }
+                            catch (err) {
+                                if (errorVariantFilePath) {
+                                    yield saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                                }
+                                if (findBestError) {
+                                    bestError = {
+                                        error: err,
+                                        args: _args,
+                                        index: _index,
+                                    };
+                                    debug = false;
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                            finally {
+                                void pool.release(1);
+                            }
+                        }))();
+                    }
+                }
+                if (pool) {
+                    yield pool.holdWait(parallel);
+                    void pool.release(parallel);
+                }
+                if (abortSignalAll === null || abortSignalAll === void 0 ? void 0 : abortSignalAll.aborted) {
+                    throw abortSignalAll.reason;
+                }
+                onCompleted();
+                yield garbageCollect(1);
+                return iterations;
+            });
+        }
+        const result = yield next();
+        return {
+            iterations: result,
+            bestError,
+        };
+    });
+}
+
+export { testVariantsRun };

package/dist/lib/test-variants/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/lib/test-variants/types.d.ts

@@ -0,0 +1,18 @@
+export declare type Obj = Record<string, any>;
+/** Options for generating error variant file path */
+export declare type GenerateErrorVariantFilePathOptions = {
+    sessionDate: Date;
+};
+/** Options for saving and replaying error-causing parameter combinations */
+export declare type SaveErrorVariantsOptions<Args, SavedArgs = Args> = {
+    /** Directory path for error variant JSON files */
+    dir: string;
+    /** Retry attempts per variant during replay phase (default: 1) */
+    retriesPerVariant?: null | number;
+    /** Custom file path generator; returns path relative to dir; null - use default path */
+    getFilePath?: null | ((options: GenerateErrorVariantFilePathOptions) => string | null);
+    /** Transform args before JSON serialization */
+    argsToJson?: null | ((args: Args) => string | SavedArgs);
+    /** Transform parsed JSON back to args */
+    jsonToArgs?: null | ((json: SavedArgs) => Args);
+};

package/dist/lib/test-variants/types.mjs

@@ -0,0 +1 @@
+

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@flemist/test-variants",
-  "version": "1.0.7",
+  "version": "2.0.0",
   "description": "Runs a test function with all possible combinations of its parameters.",
   "main": "dist/lib/index.cjs",
   "module": "dist/lib/index.mjs",
   "types": "dist/lib/index.d.ts",
   "engines": {
-    "node": ">=10.4.0",
+    "node": ">=11.14.0",
     "pnpm": ">=7.1.6"
   },
   "repository": {
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "scripts": {
-    "_prepublishOnly": "pnpm run audit && pnpm run lint && pnpm run build && pnpm run test:mocha:ci && pnpm run test:karma",
+    "_prepublishOnly": "pnpm run audit && pnpm run lint && pnpm run build && pnpm run test:mocha:ci && pnpm run test:karma && npm login",
     "audit": "pnpm audit --prod",
     "lint": "eslint ./**/*.{js,cjs,mjs,ts,tsx}",
     "lint:fix": "eslint --fix ./**/*.{js,cjs,mjs,ts,tsx}",
@@ -47,17 +47,20 @@
     "test:mocha:watch": "mocha --watch ./src/**/*.test.*",
     "test:karma": "rimraf tmp/coverage/karma && karma start --single-run --log-level debug",
     "test:mocha:ci": "rimraf tmp/coverage/mocha && nyc --all mocha ./{src,dist/lib}/**/*.test.*",
-    "coveralls": "pnpm run coverage:check && nyc report --reporter=text-lcov --temp-dir \"tmp/coverage/merge/\" | coveralls"
+    "coveralls": "pnpm run coverage:check && nyc report --reporter=text-lcov --temp-dir \"tmp/coverage/merge/\" | coveralls",
+    "mcp:tools": "mcp-project-tools"
   },
   "devDependencies": {
+    "@anthropic-ai/claude-code": "^2.0.76",
     "@babel/core": "7.18.5",
     "@babel/plugin-syntax-dynamic-import": "7.8.3",
     "@babel/plugin-transform-classes": "7.18.4",
     "@babel/plugin-transform-runtime": "7.18.5",
     "@babel/preset-env": "7.18.2",
-    "@babel/runtime-corejs3": "7.18.3",
+    "@babel/runtime-corejs3": "7.28.3",
     "@flemist/copy-glob-flat": "0.0.5",
     "@flemist/karma-custom-launcher": "0.0.0",
+    "@flemist/mcp-project-tools": "3.0.19",
     "@flemist/test-utils": "1.0.2",
     "@rollup/plugin-alias": "3.1.9",
     "@rollup/plugin-babel": "5.3.1",
@@ -67,7 +70,7 @@
     "@rollup/plugin-multi-entry": "4.1.0",
     "@rollup/plugin-node-resolve": "13.3.0",
     "@rollup/plugin-replace": "4.0.0",
-    "@rollup/plugin-typescript": "11.1.5",
+    "@rollup/plugin-typescript": "12.1.4",
     "@rollup/pluginutils": "4.2.1",
     "@types/assert": "1.5.6",
     "@types/mocha": "9.1.1",
@@ -85,9 +88,9 @@
     "karma-safari-launcher": "1.0.0",
     "mocha": "9.2.2",
     "nyc": "15.1.0",
-    "rdtsc": "3.0.4",
+    "rdtsc": "5.0.7",
     "rimraf": "3.0.2",
-    "rollup": "2.75.7",
+    "rollup": "2.79.2",
     "rollup-plugin-delete": "2.0.0",
     "rollup-plugin-istanbul": "3.0.0",
     "rollup-plugin-multi-input": "1.3.1",
@@ -101,6 +104,6 @@
     "@flemist/abort-controller-fast": "^1.0.0",
     "@flemist/async-utils": "^1.0.0",
     "@flemist/time-limits": "^1.0.1",
-    "tslib": "^2.4.0"
+    "tslib": "2.5.3"
   }
 }