@dereekb/util 13.0.0 → 13.0.2

package/test/index.cjs.js

@@ -1,38 +1,251 @@
 'use strict';
 
 var util = require('@dereekb/util');
+var makeError = require('make-error');
 
+function _assert_this_initialized$4(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$4(_this, derived, args) {
+    derived = _get_prototype_of$4(derived);
+    return _possible_constructor_return$4(_this, _is_native_reflect_construct$4() ? Reflect.construct(derived, [], _get_prototype_of$4(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$4(o) {
+    _get_prototype_of$4 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$4(o);
+}
+function _inherits$4(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$4(subClass, superClass);
+}
+function _possible_constructor_return$4(self, call) {
+    if (call && (_type_of$4(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$4(self);
+}
+function _set_prototype_of$4(o, p) {
+    _set_prototype_of$4 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$4(o, p);
+}
+function _type_of$4(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$4() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$4 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Passes the error to the TestDoneCallback.
  * @param done
  * @param e
- */
-function failWithTestDoneCallback(done, e = new Error('failed test')) {
-  if (done.fail != null) {
-    done.fail(e);
-  } else {
-    done(e);
-  }
+ */ function failWithTestDoneCallback(done) {
+    var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new Error('failed test');
+    if (done.fail != null) {
+        done.fail(e);
+    } else {
+        done(e);
+    }
 }
 /**
  * Creates a new TestDoneCallbackRef.
  *
  * Used to create a promise reference that can be used to assert that a test function was called.
- */
-function testDoneCallbackRef() {
-  const _promise = util.promiseReference();
-  const done = e => {
-    if (e) {
-      _promise.reject(e);
-    } else {
-      _promise.resolve();
-    }
-  };
-  done.fail = done;
-  return {
-    _promise,
-    done
-  };
+ */ function testDoneCallbackRef() {
+    var _promise = util.promiseReference();
+    var done = function done(e) {
+        if (e) {
+            _promise.reject(e);
+        } else {
+            _promise.resolve();
+        }
+    };
+    done.fail = done;
+    return {
+        _promise: _promise,
+        done: done
+    };
 }
 /**
  * Wraps a callback-based test (using done) for Vitest compatibility.
@@ -53,403 +266,822 @@ function testDoneCallbackRef() {
  *   // async test code
  *   done();
  * }));
- */
-function callbackTest(testFn) {
-  return async () => {
-    const done = testDoneCallbackRef();
-    await testFn(done.done);
-    return done._promise.promise;
-  };
+ */ function callbackTest(testFn) {
+    return function() {
+        return _async_to_generator$2(function() {
+            var done;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        done = testDoneCallbackRef();
+                        return [
+                            4,
+                            testFn(done.done)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            done._promise.promise
+                        ];
+                }
+            });
+        })();
+    };
 }
 /**
  * Abstract TestContextFixture instance.
- */
-class AbstractTestContextFixture {
-  constructor() {
-    this._instance = void 0;
-  }
-  get instance() {
-    return this._instance;
-  }
-  setInstance(instance) {
-    if (this._instance != null) {
-      throw new Error(`The testing fixture is locked. Don't call setInstance() directly.`);
-    }
-    this._instance = instance;
-    return () => {
-      delete this._instance;
-    };
-  }
-}
+ */ var AbstractTestContextFixture = /*#__PURE__*/ function() {
+    function AbstractTestContextFixture() {
+        _class_call_check$4(this, AbstractTestContextFixture);
+        _define_property$2(this, "_instance", void 0);
+    }
+    _create_class(AbstractTestContextFixture, [
+        {
+            key: "instance",
+            get: function get() {
+                return this._instance;
+            }
+        },
+        {
+            key: "setInstance",
+            value: function setInstance(instance) {
+                var _this = this;
+                if (this._instance != null) {
+                    throw new Error("The testing fixture is locked. Don't call setInstance() directly.");
+                }
+                this._instance = instance;
+                return function() {
+                    delete _this._instance;
+                };
+            }
+        }
+    ]);
+    return AbstractTestContextFixture;
+}();
 /**
  * Abstract TestContextFixture instance with a parent.
- */
-class AbstractChildTestContextFixture extends AbstractTestContextFixture {
-  constructor(parent) {
-    super();
-    this.parent = void 0;
-    this.parent = parent;
-  }
-}
+ */ var AbstractChildTestContextFixture = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$4(AbstractChildTestContextFixture, AbstractTestContextFixture);
+    function AbstractChildTestContextFixture(parent) {
+        _class_call_check$4(this, AbstractChildTestContextFixture);
+        var _this;
+        _this = _call_super$4(this, AbstractChildTestContextFixture), _define_property$2(_this, "parent", void 0);
+        _this.parent = parent;
+        return _this;
+    }
+    return AbstractChildTestContextFixture;
+}(AbstractTestContextFixture);
 /**
  * Creates a TestContextBuilderFunction given the input builder.
  *
  * @param builder
  * @returns
- */
-function testContextBuilder(builder) {
-  return inputConfig => {
-    const config = builder.buildConfig(inputConfig);
-    return buildTests => {
-      const fixture = builder.buildFixture(config);
-      // add before each
-      if (builder.beforeEach != null) {
-        beforeEach(builder.beforeEach);
-      }
-      // add tests
-      useTestContextFixture({
-        fixture,
-        /**
-         * Build tests by passing the fixture to the testing functions.
-         *
-         * This will inject all tests and sub lifecycle items.
-         */
-        buildTests,
-        initInstance: () => builder.setupInstance(config),
-        destroyInstance: instance => builder.teardownInstance(instance, config)
-      });
-      // add after each
-      if (builder.afterEach != null) {
-        afterEach(builder.afterEach);
-      }
+ */ function testContextBuilder(builder) {
+    return function(inputConfig) {
+        var config = builder.buildConfig(inputConfig);
+        return function(buildTests) {
+            var fixture = builder.buildFixture(config);
+            // add before each
+            if (builder.beforeEach != null) {
+                beforeEach(builder.beforeEach);
+            }
+            // add tests
+            useTestContextFixture({
+                fixture: fixture,
+                /**
+                 * Build tests by passing the fixture to the testing functions.
+                 *
+                 * This will inject all tests and sub lifecycle items.
+                 */ buildTests: buildTests,
+                initInstance: function initInstance() {
+                    return builder.setupInstance(config);
+                },
+                destroyInstance: function destroyInstance(instance) {
+                    return builder.teardownInstance(instance, config);
+                }
+            });
+            // add after each
+            if (builder.afterEach != null) {
+                afterEach(builder.afterEach);
+            }
+        };
     };
-  };
 }
 /**
  * Creates a test context and configurations that will initialize an instance
- */
-function useTestContextFixture(config) {
-  const {
-    buildTests,
-    fixture,
-    initInstance,
-    destroyInstance
-  } = config;
-  let clearInstance;
-  let instance;
-  // Create an instance
-  beforeEach(async () => {
+ */ function useTestContextFixture(config) {
+    var buildTests = config.buildTests, fixture = config.fixture, initInstance = config.initInstance, destroyInstance = config.destroyInstance;
+    var clearInstance;
+    var instance;
+    // Create an instance
+    beforeEach(function() {
+        return _async_to_generator$2(function() {
+            var e;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            initInstance()
+                        ];
+                    case 1:
+                        instance = _state.sent();
+                        clearInstance = fixture.setInstance(instance);
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        e = _state.sent();
+                        console.error('Failed building a test instance due to an error in buildInstance(). Error: ', e);
+                        if (clearInstance) {
+                            clearInstance();
+                        }
+                        throw e;
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    // Declare tests
+    buildTests(fixture);
+    // Cleanup
+    afterEach(function() {
+        return _async_to_generator$2(function() {
+            var e;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (clearInstance) {
+                            clearInstance();
+                        }
+                        if (fixture.instance != null) {
+                            console.warn('Expected instance to be set on fixture for cleanup but was set to something else.');
+                        }
+                        if (!destroyInstance) return [
+                            3,
+                            4
+                        ];
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            destroyInstance(instance)
+                        ];
+                    case 2:
+                        _state.sent();
+                        instance = undefined;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        console.error('Failed due to error in destroyInstance()');
+                        throw e;
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+}
+
+function _assert_this_initialized$3(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
     try {
-      instance = await initInstance();
-      clearInstance = fixture.setInstance(instance);
-    } catch (e) {
-      console.error('Failed building a test instance due to an error in buildInstance(). Error: ', e);
-      if (clearInstance) {
-        clearInstance();
-      }
-      throw e;
-    }
-  });
-  // Declare tests
-  buildTests(fixture);
-  // Cleanup
-  afterEach(async () => {
-    if (clearInstance) {
-      clearInstance();
-    }
-    if (fixture.instance != null) {
-      console.warn('Expected instance to be set on fixture for cleanup but was set to something else.');
-    }
-    if (destroyInstance) {
-      try {
-        await destroyInstance(instance);
-        instance = undefined;
-      } catch (e) {
-        console.error('Failed due to error in destroyInstance()');
-        throw e;
-      }
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
     }
-  });
 }
-
-class AbstractWrappedFixture {
-  constructor(fixture) {
-    this.fixture = void 0;
-    this.fixture = fixture;
-  }
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$3(_this, derived, args) {
+    derived = _get_prototype_of$3(derived);
+    return _possible_constructor_return$3(_this, _is_native_reflect_construct$3() ? Reflect.construct(derived, [], _get_prototype_of$3(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
 }
-class AbstractWrappedFixtureWithInstance extends AbstractTestContextFixture {
-  constructor(parent) {
-    super();
-    this.parent = void 0;
-    this.parent = parent;
-  }
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$3(o) {
+    _get_prototype_of$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$3(o);
 }
+function _inherits$3(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$3(subClass, superClass);
+}
+function _possible_constructor_return$3(self, call) {
+    if (call && (_type_of$3(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$3(self);
+}
+function _set_prototype_of$3(o, p) {
+    _set_prototype_of$3 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$3(o, p);
+}
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$3() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$3 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var AbstractWrappedFixture = function AbstractWrappedFixture(fixture) {
+    _class_call_check$3(this, AbstractWrappedFixture);
+    _define_property$1(this, "fixture", void 0);
+    this.fixture = fixture;
+};
+var AbstractWrappedFixtureWithInstance = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$3(AbstractWrappedFixtureWithInstance, AbstractTestContextFixture);
+    function AbstractWrappedFixtureWithInstance(parent) {
+        _class_call_check$3(this, AbstractWrappedFixtureWithInstance);
+        var _this;
+        _this = _call_super$3(this, AbstractWrappedFixtureWithInstance), _define_property$1(_this, "parent", void 0);
+        _this.parent = parent;
+        return _this;
+    }
+    return AbstractWrappedFixtureWithInstance;
+}(AbstractTestContextFixture);
 /**
  * Wraps the input TestContextFactory to emit another type of Fixture for tests.
  *
  * @returns
- */
-function wrapTestContextFactory(config) {
-  return factory => {
-    return buildTests => {
-      factory(inputFixture => {
-        const wrap = config.wrapFixture(inputFixture);
-        let effect;
-        // add before each
-        if (config.setupWrap != null) {
-          beforeEach(async () => {
-            effect = await config.setupWrap(wrap);
-          });
-        }
-        // add tests
-        buildTests(wrap);
-        // add after each
-        if (config.teardownWrap != null) {
-          afterEach(async () => {
-            await config.teardownWrap(wrap, effect);
-          });
-        }
-      });
+ */ function wrapTestContextFactory(config) {
+    return function(factory) {
+        return function(buildTests) {
+            factory(function(inputFixture) {
+                var wrap = config.wrapFixture(inputFixture);
+                var effect;
+                // add before each
+                if (config.setupWrap != null) {
+                    beforeEach(function() {
+                        return _async_to_generator$1(function() {
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            config.setupWrap(wrap)
+                                        ];
+                                    case 1:
+                                        effect = _state.sent();
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                }
+                // add tests
+                buildTests(wrap);
+                // add after each
+                if (config.teardownWrap != null) {
+                    afterEach(function() {
+                        return _async_to_generator$1(function() {
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            config.teardownWrap(wrap, effect)
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                }
+            });
+        };
     };
-  };
 }
 function instanceWrapTestContextFactory(config) {
-  return wrapTestContextFactory({
-    wrapFixture: config.wrapFixture,
-    setupWrap: async wrap => {
-      const instance = await config.makeInstance(wrap);
-      const effect = wrap.setInstance(instance);
-      if (config.setupInstance) {
-        await config.setupInstance(instance, wrap);
-      }
-      return effect;
-    },
-    teardownWrap: async (wrap, deleteInstanceEffect) => {
-      deleteInstanceEffect?.();
-      if (config.teardownInstance) {
-        await config.teardownInstance(wrap.instance);
-      }
-    }
-  });
+    return wrapTestContextFactory({
+        wrapFixture: config.wrapFixture,
+        setupWrap: function setupWrap(wrap) {
+            return _async_to_generator$1(function() {
+                var instance, effect;
+                return _ts_generator$1(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                config.makeInstance(wrap)
+                            ];
+                        case 1:
+                            instance = _state.sent();
+                            effect = wrap.setInstance(instance);
+                            if (!config.setupInstance) return [
+                                3,
+                                3
+                            ];
+                            return [
+                                4,
+                                config.setupInstance(instance, wrap)
+                            ];
+                        case 2:
+                            _state.sent();
+                            _state.label = 3;
+                        case 3:
+                            return [
+                                2,
+                                effect
+                            ];
+                    }
+                });
+            })();
+        },
+        teardownWrap: function teardownWrap(wrap, deleteInstanceEffect) {
+            return _async_to_generator$1(function() {
+                return _ts_generator$1(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            deleteInstanceEffect === null || deleteInstanceEffect === void 0 ? void 0 : deleteInstanceEffect();
+                            if (!config.teardownInstance) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                config.teardownInstance(wrap.instance)
+                            ];
+                        case 1:
+                            _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    });
 }
 
 /**
  * Creates a test context and configurations that provides a function to build tests based on the configuration.
- */
-function useTestFunctionFixture(config, buildTests) {
-  const {
-    fn
-  } = config;
-  const forward = util.forwardFunction(fn);
-  buildTests(forward);
+ */ function useTestFunctionFixture(config, buildTests) {
+    var fn = config.fn;
+    var forward = util.forwardFunction(fn);
+    buildTests(forward);
 }
 /**
  * Creates a test context and configurations that provides a function to build tests based on the configuration.
- */
-function useTestFunctionMapFixture(config, buildTests) {
-  const forwardedFunctions = util.mapObjectMap(config.fns, fn => util.forwardFunction(fn));
-  buildTests(forwardedFunctions);
+ */ function useTestFunctionMapFixture(config, buildTests) {
+    var forwardedFunctions = util.mapObjectMap(config.fns, function(fn) {
+        return util.forwardFunction(fn);
+    });
+    buildTests(forwardedFunctions);
 }
 
-var makeError = {exports: {}};
-
-(function (module, exports$1) {
-
-	// ===================================================================
-
-	var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
-	var defineProperty = Object.defineProperty;
-
-	// -------------------------------------------------------------------
-
-	var captureStackTrace = Error.captureStackTrace;
-	if (captureStackTrace === undefined) {
-	  captureStackTrace = function captureStackTrace(error) {
-	    var container = new Error();
-
-	    defineProperty(error, "stack", {
-	      configurable: true,
-	      get: function getStack() {
-	        var stack = container.stack;
-
-	        // Replace property with value for faster future accesses.
-	        defineProperty(this, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-
-	        return stack;
-	      },
-	      set: function setStack(stack) {
-	        defineProperty(error, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-	      },
-	    });
-	  };
-	}
-
-	// -------------------------------------------------------------------
-
-	function BaseError(message) {
-	  if (message !== undefined) {
-	    defineProperty(this, "message", {
-	      configurable: true,
-	      value: message,
-	      writable: true,
-	    });
-	  }
-
-	  var cname = this.constructor.name;
-	  if (cname !== undefined && cname !== this.name) {
-	    defineProperty(this, "name", {
-	      configurable: true,
-	      value: cname,
-	      writable: true,
-	    });
-	  }
-
-	  captureStackTrace(this, this.constructor);
-	}
-
-	BaseError.prototype = Object.create(Error.prototype, {
-	  // See: https://github.com/JsCommunity/make-error/issues/4
-	  constructor: {
-	    configurable: true,
-	    value: BaseError,
-	    writable: true,
-	  },
-	});
-
-	// -------------------------------------------------------------------
-
-	// Sets the name of a function if possible (depends of the JS engine).
-	var setFunctionName = (function() {
-	  function setFunctionName(fn, name) {
-	    return defineProperty(fn, "name", {
-	      configurable: true,
-	      value: name,
-	    });
-	  }
-	  try {
-	    var f = function() {};
-	    setFunctionName(f, "foo");
-	    if (f.name === "foo") {
-	      return setFunctionName;
-	    }
-	  } catch (_) {}
-	})();
-
-	// -------------------------------------------------------------------
-
-	function makeError(constructor, super_) {
-	  if (super_ == null || super_ === Error) {
-	    super_ = BaseError;
-	  } else if (typeof super_ !== "function") {
-	    throw new TypeError("super_ should be a function");
-	  }
-
-	  var name;
-	  if (typeof constructor === "string") {
-	    name = constructor;
-	    constructor =
-	      construct !== undefined
-	        ? function() {
-	            return construct(super_, arguments, this.constructor);
-	          }
-	        : function() {
-	            super_.apply(this, arguments);
-	          };
-
-	    // If the name can be set, do it once and for all.
-	    if (setFunctionName !== undefined) {
-	      setFunctionName(constructor, name);
-	      name = undefined;
-	    }
-	  } else if (typeof constructor !== "function") {
-	    throw new TypeError("constructor should be either a string or a function");
-	  }
-
-	  // Also register the super constructor also as `constructor.super_` just
-	  // like Node's `util.inherits()`.
-	  //
-	  // eslint-disable-next-line dot-notation
-	  constructor.super_ = constructor["super"] = super_;
-
-	  var properties = {
-	    constructor: {
-	      configurable: true,
-	      value: constructor,
-	      writable: true,
-	    },
-	  };
-
-	  // If the name could not be set on the constructor, set it on the
-	  // prototype.
-	  if (name !== undefined) {
-	    properties.name = {
-	      configurable: true,
-	      value: name,
-	      writable: true,
-	    };
-	  }
-	  constructor.prototype = Object.create(super_.prototype, properties);
-
-	  return constructor;
-	}
-	exports$1 = module.exports = makeError;
-	exports$1.BaseError = BaseError; 
-} (makeError, makeError.exports));
-
-var makeErrorExports = makeError.exports;
-
-/**
- * Testing utilities for handling expected failures and errors.
- */
+function _assert_this_initialized$2(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$2(_this, derived, args) {
+    derived = _get_prototype_of$2(derived);
+    return _possible_constructor_return$2(_this, _is_native_reflect_construct$2() ? Reflect.construct(derived, args || [], _get_prototype_of$2(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$2(o) {
+    _get_prototype_of$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$2(o);
+}
+function _inherits$2(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$2(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return$2(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$2(self);
+}
+function _set_prototype_of$2(o, p) {
+    _set_prototype_of$2 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$2(o, p);
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$2() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$2 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 // MARK: Errors
 /**
  * Error thrown by fail() and used by expectError()
- */
-class ExpectedFailError extends makeErrorExports.BaseError {}
+ */ var ExpectedFailError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(ExpectedFailError, BaseError);
+    function ExpectedFailError() {
+        _class_call_check$2(this, ExpectedFailError);
+        return _call_super$2(this, ExpectedFailError, arguments);
+    }
+    return ExpectedFailError;
+}(makeError.BaseError);
 function failSuccessfullyError(message) {
-  return new ExpectedFailError(message);
+    return new ExpectedFailError(message);
 }
 function failSuccessfully(message) {
-  throw failSuccessfullyError(message);
+    throw failSuccessfullyError(message);
 }
 /**
  * Error thrown when success occurs when it should not have.
- */
-class UnexpectedSuccessFailureError extends makeErrorExports.BaseError {}
+ */ var UnexpectedSuccessFailureError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(UnexpectedSuccessFailureError, BaseError);
+    function UnexpectedSuccessFailureError() {
+        _class_call_check$2(this, UnexpectedSuccessFailureError);
+        return _call_super$2(this, UnexpectedSuccessFailureError, arguments);
+    }
+    return UnexpectedSuccessFailureError;
+}(makeError.BaseError);
 function failDueToSuccessError(message) {
-  return new UnexpectedSuccessFailureError(message ?? 'expected an error to occur but was successful instead');
+    return new UnexpectedSuccessFailureError(message !== null && message !== void 0 ? message : 'expected an error to occur but was successful instead');
 }
 /**
  * Error thrown when the error type was different than the expected type.
- */
-class ExpectedErrorOfSpecificTypeError extends makeErrorExports.BaseError {
-  constructor(encounteredType, expectedType) {
-    super(`The error encountered was not of the expected type. Expected: ${expectedType ?? 'n/a'}, but encountered: ${encounteredType} `);
-    this.encounteredType = void 0;
-    this.expectedType = void 0;
-    this.encounteredType = encounteredType;
-    this.expectedType = expectedType;
-  }
-}
+ */ var ExpectedErrorOfSpecificTypeError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(ExpectedErrorOfSpecificTypeError, BaseError);
+    function ExpectedErrorOfSpecificTypeError(encounteredType, expectedType) {
+        _class_call_check$2(this, ExpectedErrorOfSpecificTypeError);
+        var _this;
+        _this = _call_super$2(this, ExpectedErrorOfSpecificTypeError, [
+            "The error encountered was not of the expected type. Expected: ".concat(expectedType !== null && expectedType !== void 0 ? expectedType : 'n/a', ", but encountered: ").concat(encounteredType, " ")
+        ]), _define_property(_this, "encounteredType", void 0), _define_property(_this, "expectedType", void 0);
+        _this.encounteredType = encounteredType;
+        _this.expectedType = expectedType;
+        return _this;
+    }
+    return ExpectedErrorOfSpecificTypeError;
+}(makeError.BaseError);
 function failTest(message) {
-  throw failDueToSuccessError(message);
+    throw failDueToSuccessError(message);
 }
 function failDueToSuccess() {
-  throw failDueToSuccessError();
+    throw failDueToSuccessError();
 }
 function EXPECT_ERROR_DEFAULT_HANDLER(e) {
-  if (e instanceof ExpectedFailError) ; else {
-    throw e;
-  }
+    if (_instanceof(e, ExpectedFailError)) ; else {
+        throw e;
+    }
 }
 /**
  * Creates an ExpectFailAssertionFunction that asserts the encountered error is of the expected type using the instanceof keyword.
@@ -458,48 +1090,48 @@ function EXPECT_ERROR_DEFAULT_HANDLER(e) {
  *
  * @param expectedType
  * @returns
- */
-function expectFailAssertErrorType(expectedType) {
-  return error => {
-    if (!(error instanceof expectedType)) {
-      throw new ExpectedErrorOfSpecificTypeError(error, expectedType);
-    }
-  };
+ */ function expectFailAssertErrorType(expectedType) {
+    return function(error) {
+        if (!_instanceof(error, expectedType)) {
+            throw new ExpectedErrorOfSpecificTypeError(error, expectedType);
+        }
+    };
 }
 function expectFail(errorFn, assertFailType) {
-  function handleError(e) {
-    if (e instanceof UnexpectedSuccessFailureError) {
-      throw e;
-    } else {
-      const assertionResult = assertFailType?.(e);
-      if (assertionResult === false) {
-        throw new ExpectedErrorOfSpecificTypeError(e);
-      }
-      failSuccessfully();
-    }
-  }
-  try {
-    const result = errorFn();
-    if (util.isPromise(result)) {
-      return result.then(failDueToSuccess).catch(handleError);
-    } else {
-      failDueToSuccess();
+    function handleError(e) {
+        if (_instanceof(e, UnexpectedSuccessFailureError)) {
+            throw e;
+        } else {
+            var assertionResult = assertFailType === null || assertFailType === void 0 ? void 0 : assertFailType(e);
+            if (assertionResult === false) {
+                throw new ExpectedErrorOfSpecificTypeError(e);
+            }
+            failSuccessfully();
+        }
+    }
+    try {
+        var result = errorFn();
+        if (util.isPromise(result)) {
+            return result.then(failDueToSuccess).catch(handleError);
+        } else {
+            failDueToSuccess();
+        }
+    } catch (e) {
+        handleError(e);
     }
-  } catch (e) {
-    handleError(e);
-  }
 }
-function expectSuccessfulFail(errorFn, handleError = EXPECT_ERROR_DEFAULT_HANDLER) {
-  try {
-    const result = errorFn();
-    if (util.isPromise(result)) {
-      return result.then(failDueToSuccess).catch(handleError);
-    } else {
-      failDueToSuccess();
+function expectSuccessfulFail(errorFn) {
+    var handleError = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : EXPECT_ERROR_DEFAULT_HANDLER;
+    try {
+        var result = errorFn();
+        if (util.isPromise(result)) {
+            return result.then(failDueToSuccess).catch(handleError);
+        } else {
+            failDueToSuccess();
+        }
+    } catch (e) {
+        handleError(e);
     }
-  } catch (e) {
-    handleError(e);
-  }
 }
 /**
  * Used to wrap a testing function and watch for ExpectedFailError errors in order to pass the test. Other exceptions are treated normally as failures.
@@ -509,159 +1141,297 @@ function expectSuccessfulFail(errorFn, handleError = EXPECT_ERROR_DEFAULT_HANDLE
  * @param fn
  * @param strict
  * @returns
- */
-function shouldFail(fn) {
-  const usesDoneCallback = fn.length > 0;
-  // Return a function that checks arguments at runtime to avoid done callback deprecation warning
-  return async function () {
-    const {
-      done,
-      _promise
-    } = testDoneCallbackRef();
-    function handleError(e) {
-      if (!(e instanceof ExpectedFailError)) {
-        failWithTestDoneCallback(done, e);
-      } else {
-        done();
-      }
-    }
-    try {
-      const result = expectSuccessfulFail(() => {
-        let result;
-        if (usesDoneCallback) {
-          const fakeDone = util.build({
-            base: fakeDoneHandler(),
-            build: x => {
-              x.failSuccessfully = () => {
-                fakeDone(failSuccessfullyError());
-              };
+ */ function shouldFail(fn) {
+    var usesDoneCallback = fn.length > 0;
+    // Return a function that checks arguments at runtime to avoid done callback deprecation warning
+    return function() {
+        return _async_to_generator(function() {
+            var _testDoneCallbackRef, done, _promise, result;
+            function handleError(e) {
+                if (!_instanceof(e, ExpectedFailError)) {
+                    failWithTestDoneCallback(done, e);
+                } else {
+                    done();
+                }
             }
-          });
-          const callbackWithDoneResult = fn(fakeDone);
-          if (util.isPromise(callbackWithDoneResult)) {
-            fakeDone.reject(new Error('Configured to use "done" value while returning a promise. Configure your test to use one or the other.'));
-          }
-          // return the fake done promise. Done/fail will resolve as a promise.
-          result = fakeDone._ref.promise;
-        } else {
-          result = fn();
-        }
-        return result;
-      }, handleError);
-      // If expectSuccessfulFail returns a promise, handle it
-      if (util.isPromise(result)) {
-        result.catch(handleError);
-      }
-    } catch (e) {
-      // Handle synchronous errors
-      handleError(e);
-    }
-    return _promise.promise;
-  };
+            return _ts_generator(this, function(_state) {
+                _testDoneCallbackRef = testDoneCallbackRef(), done = _testDoneCallbackRef.done, _promise = _testDoneCallbackRef._promise;
+                try {
+                    result = expectSuccessfulFail(function() {
+                        var result;
+                        if (usesDoneCallback) {
+                            var fakeDone = util.build({
+                                base: fakeDoneHandler(),
+                                build: function build(x) {
+                                    x.failSuccessfully = function() {
+                                        fakeDone(failSuccessfullyError());
+                                    };
+                                }
+                            });
+                            var callbackWithDoneResult = fn(fakeDone);
+                            if (util.isPromise(callbackWithDoneResult)) {
+                                fakeDone.reject(new Error('Configured to use "done" value while returning a promise. Configure your test to use one or the other.'));
+                            }
+                            // return the fake done promise. Done/fail will resolve as a promise.
+                            result = fakeDone._ref.promise;
+                        } else {
+                            result = fn();
+                        }
+                        return result;
+                    }, handleError);
+                    // If expectSuccessfulFail returns a promise, handle it
+                    if (util.isPromise(result)) {
+                        result.catch(handleError);
+                    }
+                } catch (e) {
+                    // Handle synchronous errors
+                    handleError(e);
+                }
+                return [
+                    2,
+                    _promise.promise
+                ];
+            });
+        })();
+    };
 }
 function itShouldFail(describeOrFn, fn) {
-  let description;
-  if (typeof describeOrFn === 'string') {
-    description = `should fail ${describeOrFn}`;
-  } else {
-    fn = describeOrFn;
-    description = 'should fail';
-  }
-  it(description, shouldFail(fn));
+    var description;
+    if (typeof describeOrFn === 'string') {
+        description = "should fail ".concat(describeOrFn);
+    } else {
+        fn = describeOrFn;
+        description = 'should fail';
+    }
+    it(description, shouldFail(fn));
 }
 function fakeDoneHandler() {
-  const promiseRef = util.promiseReference();
-  const doneHandler = promiseRef.resolve;
-  const failHandler = e => {
-    promiseRef.reject(e);
-  };
-  const fakeDone = error => {
-    if (error) {
-      failHandler(error);
-    } else {
-      doneHandler(0);
-    }
-  };
-  fakeDone.fail = error => {
-    failHandler(error);
-  };
-  fakeDone._ref = promiseRef;
-  fakeDone.promise = promiseRef.promise;
-  fakeDone.resolve = promiseRef.resolve;
-  fakeDone.reject = promiseRef.reject;
-  return fakeDone;
+    var promiseRef = util.promiseReference();
+    var doneHandler = promiseRef.resolve;
+    var failHandler = function failHandler(e) {
+        promiseRef.reject(e);
+    };
+    var fakeDone = function fakeDone(error) {
+        if (error) {
+            failHandler(error);
+        } else {
+            doneHandler(0);
+        }
+    };
+    fakeDone.fail = function(error) {
+        failHandler(error);
+    };
+    fakeDone._ref = promiseRef;
+    fakeDone.promise = promiseRef.promise;
+    fakeDone.resolve = promiseRef.resolve;
+    fakeDone.reject = promiseRef.reject;
+    return fakeDone;
 }
 
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
 /**
  * @deprecated Use AbstractTestContextFixture from shared instead. This is kept for backwards compatibility.
- */
-class AbstractJestTestContextFixture extends AbstractTestContextFixture {}
+ */ var AbstractJestTestContextFixture = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$1(AbstractJestTestContextFixture, AbstractTestContextFixture);
+    function AbstractJestTestContextFixture() {
+        _class_call_check$1(this, AbstractJestTestContextFixture);
+        return _call_super$1(this, AbstractJestTestContextFixture, arguments);
+    }
+    return AbstractJestTestContextFixture;
+}(AbstractTestContextFixture);
 /**
  * @deprecated Use AbstractChildTestContextFixture from shared instead. This is kept for backwards compatibility.
- */
-class AbstractChildJestTestContextFixture extends AbstractChildTestContextFixture {}
+ */ var AbstractChildJestTestContextFixture = /*#__PURE__*/ function(AbstractChildTestContextFixture) {
+    _inherits$1(AbstractChildJestTestContextFixture, AbstractChildTestContextFixture);
+    function AbstractChildJestTestContextFixture() {
+        _class_call_check$1(this, AbstractChildJestTestContextFixture);
+        return _call_super$1(this, AbstractChildJestTestContextFixture, arguments);
+    }
+    return AbstractChildJestTestContextFixture;
+}(AbstractChildTestContextFixture);
 /**
  * @deprecated Use testContextBuilder from shared instead. This is kept for backwards compatibility.
- */
-const jestTestContextBuilder = testContextBuilder;
+ */ var jestTestContextBuilder = testContextBuilder;
 /**
  * @deprecated Use useContextFixture from shared instead. This is kept for backwards compatibility.
- */
-const useJestContextFixture = useTestContextFixture;
+ */ var useJestContextFixture = useTestContextFixture;
 
-/**
- * https://github.com/facebook/jest/issues/11698
- *
- * Since fail() was silently removed, we redefine it.
- */
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
 /**
  * @deprecated Use failWithTestDoneCallback from shared instead. This is kept for backwards compatibility.
- */
-const failWithJestDoneCallback = failWithTestDoneCallback;
+ */ var failWithJestDoneCallback = failWithTestDoneCallback;
 // MARK: Errors
 /**
  * @deprecated Use ExpectedFailError from shared instead. This is kept for backwards compatibility.
- */
-class JestExpectedFailError extends ExpectedFailError {}
+ */ var JestExpectedFailError = /*#__PURE__*/ function(ExpectedFailError) {
+    _inherits(JestExpectedFailError, ExpectedFailError);
+    function JestExpectedFailError() {
+        _class_call_check(this, JestExpectedFailError);
+        return _call_super(this, JestExpectedFailError, arguments);
+    }
+    return JestExpectedFailError;
+}(ExpectedFailError);
 /**
  * @deprecated Use UnexpectedSuccessFailureError from shared instead. This is kept for backwards compatibility.
- */
-class JestUnexpectedSuccessFailureError extends UnexpectedSuccessFailureError {}
+ */ var JestUnexpectedSuccessFailureError = /*#__PURE__*/ function(UnexpectedSuccessFailureError) {
+    _inherits(JestUnexpectedSuccessFailureError, UnexpectedSuccessFailureError);
+    function JestUnexpectedSuccessFailureError() {
+        _class_call_check(this, JestUnexpectedSuccessFailureError);
+        return _call_super(this, JestUnexpectedSuccessFailureError, arguments);
+    }
+    return JestUnexpectedSuccessFailureError;
+}(UnexpectedSuccessFailureError);
 /**
  * @deprecated Use ExpectedErrorOfSpecificTypeError from shared instead. This is kept for backwards compatibility.
- */
-class JestExpectedErrorOfSpecificTypeError extends ExpectedErrorOfSpecificTypeError {}
+ */ var JestExpectedErrorOfSpecificTypeError = /*#__PURE__*/ function(ExpectedErrorOfSpecificTypeError) {
+    _inherits(JestExpectedErrorOfSpecificTypeError, ExpectedErrorOfSpecificTypeError);
+    function JestExpectedErrorOfSpecificTypeError() {
+        _class_call_check(this, JestExpectedErrorOfSpecificTypeError);
+        return _call_super(this, JestExpectedErrorOfSpecificTypeError, arguments);
+    }
+    return JestExpectedErrorOfSpecificTypeError;
+}(ExpectedErrorOfSpecificTypeError);
 /**
  * @deprecated Use failWithTestDoneCallback with failDueToSuccessError from shared instead. This is kept for backwards compatibility.
- */
-function failWithDoneDueToSuccess(done) {
-  failWithTestDoneCallback(done, failDueToSuccessError());
+ */ function failWithDoneDueToSuccess(done) {
+    failWithTestDoneCallback(done, failDueToSuccessError());
 }
 /**
  * @deprecated Use expectFailAssertErrorType from shared instead. This is kept for backwards compatibility.
- */
-const jestExpectFailAssertErrorType = expectFailAssertErrorType;
+ */ var jestExpectFailAssertErrorType = expectFailAssertErrorType;
 
 /**
  * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
  *
  * @deprecated Use wrapTestContextFactory from shared instead. This is kept for backwards compatibility.
  * @returns
- */
-const wrapJestTestContextFactory = wrapTestContextFactory;
+ */ var wrapJestTestContextFactory = wrapTestContextFactory;
 /**
  * @deprecated Use instanceWrapTestContextFactory from shared instead. This is kept for backwards compatibility.
- */
-const instanceWrapJestTestContextFactory = instanceWrapTestContextFactory;
+ */ var instanceWrapJestTestContextFactory = instanceWrapTestContextFactory;
 
 /**
  * @deprecated Use useTestFunctionFixture from shared instead. This is kept for backwards compatibility.
- */
-const useJestFunctionFixture = useTestFunctionFixture;
+ */ var useJestFunctionFixture = useTestFunctionFixture;
 /**
  * @deprecated Use useTestFunctionMapFixture from shared instead. This is kept for backwards compatibility.
- */
-const useJestFunctionMapFixture = useTestFunctionMapFixture;
+ */ var useJestFunctionMapFixture = useTestFunctionMapFixture;
 
 exports.AbstractChildJestTestContextFixture = AbstractChildJestTestContextFixture;
 exports.AbstractChildTestContextFixture = AbstractChildTestContextFixture;