"use strict";
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);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  FalsyRejectionError: () => FalsyRejectionError,
  PromiseTimeoutError: () => PromiseTimeoutError,
  getTrial: () => getTrial,
  trial: () => trial
});
module.exports = __toCommonJS(src_exports);

// src/getTrial.ts
var getTrial = () => {
  let resolver;
  let rejecter;
  const promise = new Promise((resolve, reject) => {
    resolver = resolve;
    rejecter = reject;
  });
  return [promise, resolver, rejecter];
};

// src/PromiseTimeoutError.ts
var PromiseTimeoutError = class extends Error {
  constructor(promise, timeout) {
    super(`Promise timeout ${timeout}ms`);
    this.promise = promise;
    this.timeout = timeout;
  }
};

// src/FalsyRejectionError.ts
var FalsyRejectionError = class extends Error {
  constructor(reason) {
    super(`Cannot reject from a trial with falsy reason (rejected ${reason})`);
    this.reason = reason;
  }
};

// src/sleep.ts
var sleep = (time) => {
  const [promise, resolve, reject] = getTrial();
  const timeout = setTimeout(resolve, time);
  const cleaner = () => {
    clearTimeout(timeout);
    resolve();
  };
  const interrupter = (reason) => {
    clearTimeout(timeout);
    reject(reason);
  };
  return [promise, cleaner, interrupter];
};

// src/trial.ts
var trial = (promise, timeout) => {
  const ms = Number(timeout);
  if (ms > 0) {
    const [sleepPromise, clean, interrupt] = sleep(ms);
    promise.then(clean).catch(interrupt);
    const timeoutPromise = sleepPromise.then(() => Promise.reject(new PromiseTimeoutError(promise, ms)));
    return trial(Promise.race([promise, timeoutPromise]));
  }
  return promise.then((value) => [value, void 0]).catch((reason) => [void 0, reason ? reason : new FalsyRejectionError(reason)]);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  FalsyRejectionError,
  PromiseTimeoutError,
  getTrial,
  trial
});