@bybrave/retry2 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011:
+Tim Koschützki (tim@debuggable.com)
+Felix Geisendörfer (felix@debuggable.com)
+Copyright (c) 2026 bybrave (maintained fork @bybrave/retry2)
+
+ 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

@@ -0,0 +1,62 @@
+# @bybrave/retry2
+
+Maintained, drop-in fork of [`retry`](https://github.com/tim-kos/node-retry) — an abstraction for exponential-backoff retries of failing operations.
+
+The original has had no release since 2021 (`0.13.1`) while still pulling ~450M downloads/month, with types living in a separate `@types/retry` (~133M/month). This fork **bundles the TypeScript types**, fixes an infinite-retries hang, and ships ESM. The API is unchanged.
+
+```sh
+npm install @bybrave/retry2
+```
+
+```js
+const retry = require('@bybrave/retry2');        // CommonJS
+import retry from '@bybrave/retry2';              // ESM (default)
+import { operation, timeouts } from '@bybrave/retry2'; // ESM (named)
+```
+
+## What's fixed
+
+| Issue | Problem | Fix |
+|---|---|---|
+| — | Types shipped separately as `@types/retry`. | **Types are bundled** — no extra install. |
+| [#83](https://github.com/tim-kos/node-retry/issues/83) | Under TypeScript 4.4+, `import { timeouts } from 'retry'` compiled to an indirect call and broke because `timeouts()` relied on `this`. | `timeouts()` calls `createTimeout` directly — no `this`, so named imports work everywhere. |
+| [#84](https://github.com/tim-kos/node-retry/issues/84) | `retries: Infinity` built an infinite-length timeouts array — a hang / out-of-memory. | `retries: Infinity` is treated as "retry forever" without precomputing an infinite array. |
+| [#73](https://github.com/tim-kos/node-retry/issues/73) | No way to know how long until the next retry (for logging like "will retry in 16s"). | New `operation.getTimeout()` returns the scheduled delay in ms. |
+| [#93](https://github.com/tim-kos/node-retry/issues/93) | `undefined` option values overrode the defaults (`{ retries: undefined }` → 0 retries). | `undefined` values are ignored, so defaults stand. |
+| [#65](https://github.com/tim-kos/node-retry/issues/65) | `reset()` left accumulated errors in place. | `reset()` also clears the error list. |
+
+`#60` (forever operations leaking errors) was already fixed in `0.13.1` and is verified by the tests here.
+
+## `operation.getTimeout()`
+
+Returns the delay in milliseconds before the next scheduled attempt (or `null` before the first retry), so you can log it:
+
+```js
+const op = retry.operation({ retries: 5 });
+op.attempt(() => {
+  doSomething((err) => {
+    if (op.retry(err)) {
+      console.warn(`request failed, retrying in ${op.getTimeout()}ms`);
+      return;
+    }
+  });
+});
+```
+
+## Migration from `retry`
+
+Replace the dependency and the import, and remove `@types/retry` from your devDependencies — the types are built in. Everything behaves the same, plus the fixes above.
+
+## Support
+
+If this package saves you time, you can support maintenance:
+
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-buy%20me%20a%20coffee-FF5E5B?logo=kofi&logoColor=white)](https://ko-fi.com/bybrave)
+[![Bitcoin](https://img.shields.io/badge/Bitcoin-BTC-F7931A?logo=bitcoin&logoColor=white)](#support)
+
+Bitcoin (BTC): `bc1q37557q5jpeaxqydzwvf3jgj7zhnfpn2td3q40q`
+
+## Credits & license
+
+MIT, same as the original — see [LICENSE](./LICENSE).
+Based on [node-retry](https://github.com/tim-kos/node-retry) by Tim Koschützki, Felix Geisendörfer and contributors.

package/dist/index.cjs

@@ -0,0 +1,268 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.js
+var retry2_exports = {};
+__export(retry2_exports, {
+  createTimeout: () => createTimeout,
+  default: () => retry2_default,
+  operation: () => operation,
+  timeouts: () => timeouts,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(retry2_exports);
+
+// lib/retry.js
+var retry_exports = {};
+__export(retry_exports, {
+  createTimeout: () => createTimeout,
+  operation: () => operation,
+  timeouts: () => timeouts,
+  wrap: () => wrap
+});
+
+// lib/retry_operation.js
+function RetryOperation(timeouts2, options) {
+  if (typeof options === "boolean") {
+    options = { forever: options };
+  }
+  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts2));
+  this._timeouts = timeouts2;
+  this._options = options || {};
+  this._maxRetryTime = options && options.maxRetryTime || Infinity;
+  this._fn = null;
+  this._errors = [];
+  this._attempts = 1;
+  this._operationTimeout = null;
+  this._operationTimeoutCb = null;
+  this._timeout = null;
+  this._operationStart = null;
+  this._timer = null;
+  this._lastTimeout = null;
+  if (this._options.forever) {
+    this._cachedTimeouts = this._timeouts.slice(0);
+  }
+}
+RetryOperation.prototype.reset = function() {
+  this._attempts = 1;
+  this._timeouts = this._originalTimeouts.slice(0);
+  this._errors = [];
+};
+RetryOperation.prototype.stop = function() {
+  if (this._timeout) {
+    clearTimeout(this._timeout);
+  }
+  if (this._timer) {
+    clearTimeout(this._timer);
+  }
+  this._timeouts = [];
+  this._cachedTimeouts = null;
+};
+RetryOperation.prototype.retry = function(err) {
+  if (this._timeout) {
+    clearTimeout(this._timeout);
+  }
+  if (!err) {
+    return false;
+  }
+  var currentTime = (/* @__PURE__ */ new Date()).getTime();
+  if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+    this._errors.push(err);
+    this._errors.unshift(new Error("RetryOperation timeout occurred"));
+    return false;
+  }
+  this._errors.push(err);
+  var timeout = this._timeouts.shift();
+  if (timeout === void 0) {
+    if (this._cachedTimeouts) {
+      this._errors.splice(0, this._errors.length - 1);
+      timeout = this._cachedTimeouts.slice(-1);
+    } else {
+      return false;
+    }
+  }
+  this._lastTimeout = Array.isArray(timeout) ? timeout[0] : timeout;
+  var self = this;
+  this._timer = setTimeout(function() {
+    self._attempts++;
+    if (self._operationTimeoutCb) {
+      self._timeout = setTimeout(function() {
+        self._operationTimeoutCb(self._attempts);
+      }, self._operationTimeout);
+      if (self._options.unref) {
+        self._timeout.unref();
+      }
+    }
+    self._fn(self._attempts);
+  }, timeout);
+  if (this._options.unref) {
+    this._timer.unref();
+  }
+  return true;
+};
+RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+  this._fn = fn;
+  if (timeoutOps) {
+    if (timeoutOps.timeout) {
+      this._operationTimeout = timeoutOps.timeout;
+    }
+    if (timeoutOps.cb) {
+      this._operationTimeoutCb = timeoutOps.cb;
+    }
+  }
+  var self = this;
+  if (this._operationTimeoutCb) {
+    this._timeout = setTimeout(function() {
+      self._operationTimeoutCb();
+    }, self._operationTimeout);
+  }
+  this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+  this._fn(this._attempts);
+};
+RetryOperation.prototype.try = function(fn) {
+  console.log("Using RetryOperation.try() is deprecated");
+  this.attempt(fn);
+};
+RetryOperation.prototype.start = function(fn) {
+  console.log("Using RetryOperation.start() is deprecated");
+  this.attempt(fn);
+};
+RetryOperation.prototype.start = RetryOperation.prototype.try;
+RetryOperation.prototype.errors = function() {
+  return this._errors;
+};
+RetryOperation.prototype.attempts = function() {
+  return this._attempts;
+};
+RetryOperation.prototype.getTimeout = function() {
+  return this._lastTimeout;
+};
+RetryOperation.prototype.mainError = function() {
+  if (this._errors.length === 0) {
+    return null;
+  }
+  var counts = {};
+  var mainError = null;
+  var mainErrorCount = 0;
+  for (var i = 0; i < this._errors.length; i++) {
+    var error = this._errors[i];
+    var message = error.message;
+    var count = (counts[message] || 0) + 1;
+    counts[message] = count;
+    if (count >= mainErrorCount) {
+      mainError = error;
+      mainErrorCount = count;
+    }
+  }
+  return mainError;
+};
+
+// lib/retry.js
+function operation(options) {
+  var timeoutsArray = timeouts(options);
+  return new RetryOperation(timeoutsArray, {
+    forever: options && (options.forever || options.retries === Infinity),
+    unref: options && options.unref,
+    maxRetryTime: options && options.maxRetryTime
+  });
+}
+function timeouts(options) {
+  if (options instanceof Array) {
+    return [].concat(options);
+  }
+  var opts = {
+    retries: 10,
+    factor: 2,
+    minTimeout: 1 * 1e3,
+    maxTimeout: Infinity,
+    randomize: false
+  };
+  for (var key in options) {
+    if (options[key] !== void 0) {
+      opts[key] = options[key];
+    }
+  }
+  if (opts.minTimeout > opts.maxTimeout) {
+    throw new Error("minTimeout is greater than maxTimeout");
+  }
+  var forever = opts.forever || opts.retries === Infinity;
+  var count = opts.retries === Infinity ? 0 : opts.retries;
+  var timeoutsList = [];
+  for (var i = 0; i < count; i++) {
+    timeoutsList.push(createTimeout(i, opts));
+  }
+  if (forever && !timeoutsList.length) {
+    timeoutsList.push(createTimeout(count, opts));
+  }
+  timeoutsList.sort(function(a, b) {
+    return a - b;
+  });
+  return timeoutsList;
+}
+function createTimeout(attempt, opts) {
+  var random = opts.randomize ? Math.random() + 1 : 1;
+  var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+  timeout = Math.min(timeout, opts.maxTimeout);
+  return timeout;
+}
+function wrap(obj, options, methods) {
+  if (options instanceof Array) {
+    methods = options;
+    options = null;
+  }
+  if (!methods) {
+    methods = [];
+    for (var key in obj) {
+      if (typeof obj[key] === "function") {
+        methods.push(key);
+      }
+    }
+  }
+  for (var i = 0; i < methods.length; i++) {
+    var method = methods[i];
+    var original = obj[method];
+    obj[method] = function retryWrapper(original2) {
+      var op = operation(options);
+      var args = Array.prototype.slice.call(arguments, 1);
+      var callback = args.pop();
+      args.push(function(err) {
+        if (op.retry(err)) {
+          return;
+        }
+        if (err) {
+          arguments[0] = op.mainError();
+        }
+        callback.apply(this, arguments);
+      });
+      op.attempt(function() {
+        original2.apply(obj, args);
+      });
+    }.bind(obj, original);
+    obj[method].options = options;
+  }
+}
+
+// index.js
+var retry2_default = retry_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTimeout,
+  operation,
+  timeouts,
+  wrap
+});

package/index.d.ts

@@ -0,0 +1,97 @@
+// Type definitions for @bybrave/retry2 (bundled — no separate @types needed).
+
+export interface RetryOperation {
+    /**
+     * Returns an array of all errors that have been passed to
+     * `retryOperation.retry()` so far, ordered chronologically.
+     */
+    errors(): Error[];
+
+    /**
+     * A reference to the error object that occurred most frequently. Errors are
+     * compared using the `error.message` property. Returns `null` if no errors
+     * occurred so far.
+     */
+    mainError(): Error | null;
+
+    /**
+     * Defines the function that is to be retried and executes it for the first
+     * time right away.
+     */
+    attempt(fn: (currentAttempt: number) => void, timeoutOps?: AttemptTimeoutOptions): void;
+
+    /**
+     * Returns `false` when no `error` is given, or the maximum amount of retries
+     * has been reached. Otherwise returns `true` and retries the operation after
+     * the timeout for the current attempt number.
+     */
+    retry(err?: Error | null): boolean;
+
+    /**
+     * The delay in milliseconds before the next scheduled attempt, or `null` if
+     * none has been scheduled yet. Useful for logging, e.g. "will retry in 16s".
+     */
+    getTimeout(): number | null;
+
+    /** Stops the operation being retried. */
+    stop(): void;
+
+    /**
+     * Resets the internal state of the operation object (attempts, remaining
+     * timeouts, and accumulated errors) so it can be reused.
+     */
+    reset(): void;
+
+    /** The number of attempts it took to call `fn` before it was successful. */
+    attempts(): number;
+}
+
+export interface AttemptTimeoutOptions {
+    /** A timeout in milliseconds. */
+    timeout?: number | undefined;
+    /** Callback to execute when the operation takes longer than the timeout. */
+    cb?(): void;
+}
+
+export interface TimeoutsOptions {
+    /** The maximum amount of times to retry the operation. Default 10. */
+    retries?: number | undefined;
+    /** The exponential factor to use. Default 2. */
+    factor?: number | undefined;
+    /** Milliseconds before starting the first retry. Default 1000. */
+    minTimeout?: number | undefined;
+    /** Maximum milliseconds between two retries. Default Infinity. */
+    maxTimeout?: number | undefined;
+    /** Randomizes the timeouts by multiplying a factor between 1-2. Default false. */
+    randomize?: boolean | undefined;
+}
+
+export interface OperationOptions extends TimeoutsOptions {
+    /** Whether to retry forever. Default false. */
+    forever?: boolean | undefined;
+    /** Whether to unref the setTimeout's. Default false. */
+    unref?: boolean | undefined;
+    /** The maximum time (ms) that the retried operation is allowed to run. Default Infinity. */
+    maxRetryTime?: number | undefined;
+}
+
+/** Create a new RetryOperation object. */
+export function operation(options?: OperationOptions | number[]): RetryOperation;
+
+/** Returns an array of timeouts, all representing the time in milliseconds. */
+export function timeouts(options?: TimeoutsOptions | number[]): number[];
+
+/** Create a new timeout (in milliseconds) for a given attempt. */
+export function createTimeout(attempt: number, opts: TimeoutsOptions): number;
+
+/** Wrap all functions of the `obj` with retry logic. */
+export function wrap(obj: object, options?: OperationOptions | string[], methods?: string[]): void;
+
+declare const retry: {
+    operation: typeof operation;
+    timeouts: typeof timeouts;
+    createTimeout: typeof createTimeout;
+    wrap: typeof wrap;
+};
+
+export default retry;

package/index.js

@@ -0,0 +1,5 @@
+import * as retry from './lib/retry.js';
+
+export {operation, timeouts, createTimeout, wrap} from './lib/retry.js';
+
+export default retry;

package/lib/retry.js

@@ -0,0 +1,113 @@
+import RetryOperation from './retry_operation.js';
+
+export function operation(options) {
+  var timeoutsArray = timeouts(options);
+  return new RetryOperation(timeoutsArray, {
+      forever: options && (options.forever || options.retries === Infinity),
+      unref: options && options.unref,
+      maxRetryTime: options && options.maxRetryTime
+  });
+}
+
+export function timeouts(options) {
+  if (options instanceof Array) {
+    return [].concat(options);
+  }
+
+  var opts = {
+    retries: 10,
+    factor: 2,
+    minTimeout: 1 * 1000,
+    maxTimeout: Infinity,
+    randomize: false
+  };
+  for (var key in options) {
+    // Skip undefined values so that `{ retries: undefined }` does not clobber
+    // the default (see #93).
+    if (options[key] !== undefined) {
+      opts[key] = options[key];
+    }
+  }
+
+  if (opts.minTimeout > opts.maxTimeout) {
+    throw new Error('minTimeout is greater than maxTimeout');
+  }
+
+  // `retries: Infinity` means retry forever. Building an Infinity-length array
+  // would hang / run out of memory, so treat it as forever with no precomputed
+  // timeouts (see #84).
+  var forever = opts.forever || opts.retries === Infinity;
+  var count = opts.retries === Infinity ? 0 : opts.retries;
+
+  var timeoutsList = [];
+  for (var i = 0; i < count; i++) {
+    // Call createTimeout directly rather than via `this`, so named imports keep
+    // working under bundlers that emit indirect calls, e.g. TypeScript 4.4+
+    // `import { timeouts } from ...` (see #83).
+    timeoutsList.push(createTimeout(i, opts));
+  }
+
+  if (forever && !timeoutsList.length) {
+    timeoutsList.push(createTimeout(count, opts));
+  }
+
+  // sort the array numerically ascending
+  timeoutsList.sort(function(a, b) {
+    return a - b;
+  });
+
+  return timeoutsList;
+}
+
+export function createTimeout(attempt, opts) {
+  var random = (opts.randomize)
+    ? (Math.random() + 1)
+    : 1;
+
+  var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+  timeout = Math.min(timeout, opts.maxTimeout);
+
+  return timeout;
+}
+
+export function wrap(obj, options, methods) {
+  if (options instanceof Array) {
+    methods = options;
+    options = null;
+  }
+
+  if (!methods) {
+    methods = [];
+    for (var key in obj) {
+      if (typeof obj[key] === 'function') {
+        methods.push(key);
+      }
+    }
+  }
+
+  for (var i = 0; i < methods.length; i++) {
+    var method   = methods[i];
+    var original = obj[method];
+
+    obj[method] = function retryWrapper(original) {
+      var op       = operation(options);
+      var args     = Array.prototype.slice.call(arguments, 1);
+      var callback = args.pop();
+
+      args.push(function(err) {
+        if (op.retry(err)) {
+          return;
+        }
+        if (err) {
+          arguments[0] = op.mainError();
+        }
+        callback.apply(this, arguments);
+      });
+
+      op.attempt(function() {
+        original.apply(obj, args);
+      });
+    }.bind(obj, original);
+    obj[method].options = options;
+  }
+}

package/lib/retry_operation.js

@@ -0,0 +1,175 @@
+export default function RetryOperation(timeouts, options) {
+  // Compatibility for the old (timeouts, retryForever) signature
+  if (typeof options === 'boolean') {
+    options = { forever: options };
+  }
+
+  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+  this._timeouts = timeouts;
+  this._options = options || {};
+  this._maxRetryTime = (options && options.maxRetryTime) || Infinity;
+  this._fn = null;
+  this._errors = [];
+  this._attempts = 1;
+  this._operationTimeout = null;
+  this._operationTimeoutCb = null;
+  this._timeout = null;
+  this._operationStart = null;
+  this._timer = null;
+  this._lastTimeout = null;
+
+  if (this._options.forever) {
+    this._cachedTimeouts = this._timeouts.slice(0);
+  }
+}
+
+RetryOperation.prototype.reset = function() {
+  this._attempts = 1;
+  this._timeouts = this._originalTimeouts.slice(0);
+  // Also clear accumulated errors so a reused operation does not keep growing
+  // its error list (see #65).
+  this._errors = [];
+};
+
+RetryOperation.prototype.stop = function() {
+  if (this._timeout) {
+    clearTimeout(this._timeout);
+  }
+  if (this._timer) {
+    clearTimeout(this._timer);
+  }
+
+  this._timeouts       = [];
+  this._cachedTimeouts = null;
+};
+
+RetryOperation.prototype.retry = function(err) {
+  if (this._timeout) {
+    clearTimeout(this._timeout);
+  }
+
+  if (!err) {
+    return false;
+  }
+  var currentTime = new Date().getTime();
+  if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+    this._errors.push(err);
+    this._errors.unshift(new Error('RetryOperation timeout occurred'));
+    return false;
+  }
+
+  this._errors.push(err);
+
+  var timeout = this._timeouts.shift();
+  if (timeout === undefined) {
+    if (this._cachedTimeouts) {
+      // retry forever, only keep last error
+      this._errors.splice(0, this._errors.length - 1);
+      timeout = this._cachedTimeouts.slice(-1);
+    } else {
+      return false;
+    }
+  }
+
+  // Expose the delay (ms) before the next attempt so callers can log it, e.g.
+  // "will retry in 16 seconds" (see #73). `getTimeout()` reads this.
+  this._lastTimeout = Array.isArray(timeout) ? timeout[0] : timeout;
+
+  var self = this;
+  this._timer = setTimeout(function() {
+    self._attempts++;
+
+    if (self._operationTimeoutCb) {
+      self._timeout = setTimeout(function() {
+        self._operationTimeoutCb(self._attempts);
+      }, self._operationTimeout);
+
+      if (self._options.unref) {
+          self._timeout.unref();
+      }
+    }
+
+    self._fn(self._attempts);
+  }, timeout);
+
+  if (this._options.unref) {
+      this._timer.unref();
+  }
+
+  return true;
+};
+
+RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+  this._fn = fn;
+
+  if (timeoutOps) {
+    if (timeoutOps.timeout) {
+      this._operationTimeout = timeoutOps.timeout;
+    }
+    if (timeoutOps.cb) {
+      this._operationTimeoutCb = timeoutOps.cb;
+    }
+  }
+
+  var self = this;
+  if (this._operationTimeoutCb) {
+    this._timeout = setTimeout(function() {
+      self._operationTimeoutCb();
+    }, self._operationTimeout);
+  }
+
+  this._operationStart = new Date().getTime();
+
+  this._fn(this._attempts);
+};
+
+RetryOperation.prototype.try = function(fn) {
+  console.log('Using RetryOperation.try() is deprecated');
+  this.attempt(fn);
+};
+
+RetryOperation.prototype.start = function(fn) {
+  console.log('Using RetryOperation.start() is deprecated');
+  this.attempt(fn);
+};
+
+RetryOperation.prototype.start = RetryOperation.prototype.try;
+
+RetryOperation.prototype.errors = function() {
+  return this._errors;
+};
+
+RetryOperation.prototype.attempts = function() {
+  return this._attempts;
+};
+
+// Delay in milliseconds before the next scheduled attempt, or null if none has
+// been scheduled yet (see #73).
+RetryOperation.prototype.getTimeout = function() {
+  return this._lastTimeout;
+};
+
+RetryOperation.prototype.mainError = function() {
+  if (this._errors.length === 0) {
+    return null;
+  }
+
+  var counts = {};
+  var mainError = null;
+  var mainErrorCount = 0;
+
+  for (var i = 0; i < this._errors.length; i++) {
+    var error = this._errors[i];
+    var message = error.message;
+    var count = (counts[message] || 0) + 1;
+
+    counts[message] = count;
+
+    if (count >= mainErrorCount) {
+      mainError = error;
+      mainErrorCount = count;
+    }
+  }
+
+  return mainError;
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@bybrave/retry2",
+  "version": "1.0.0",
+  "description": "Maintained fork of retry — abstraction for exponential-backoff retries, with bundled TypeScript types, an Infinity-retries fix (#84), getTimeout() (#73), and ESM",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["index.js", "index.d.ts", "lib/", "dist/"],
+  "scripts": {
+    "build": "node build/build.js",
+    "test": "node --test test/*.test.js",
+    "test-types": "tsc --noEmit --strict test/type-declarations.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {"type": "git", "url": "git+https://github.com/bybraveHQ/retry2.git"},
+  "bugs": {"url": "https://github.com/bybraveHQ/retry2/issues"},
+  "homepage": "https://github.com/bybraveHQ/retry2#readme",
+  "keywords": ["retry", "backoff", "exponential", "timeout", "repeat", "forever", "esm", "typescript"],
+  "author": "bybrave (https://github.com/bybraveHQ)",
+  "contributors": ["Tim Koschützki", "Felix Geisendörfer (authors of the original retry)"],
+  "license": "MIT",
+  "funding": "https://ko-fi.com/bybrave",
+  "engines": {"node": ">=18"},
+  "devDependencies": {"@types/node": "^20.14.0", "esbuild": "^0.23.0", "typescript": "^5.5.0"}
+}