Upgrade packages

.github/workflows/main.yml

@@ -82,7 +82,7 @@ jobs:
 
         strategy:
             matrix:
-                node-version: [12, 14, 16]
+                node-version: [16]
 
         steps:
             - uses: actions/checkout@v2

docs/index.md

@@ -262,11 +262,11 @@ URL may be a regular expression, e.g. `/\\/post\\//\\d+`
 If the response is a `Function`, it will be passed any capture groups from the regular expression along with the XMLHttpRequest object:
 
 ```js
-server.respondWith(/\/todo-items\/(\d+)/, function(xhr, id) {
+server.respondWith(/\/todo-items\/(\d+)/, function (xhr, id) {
     xhr.respond(
         200,
         { "Content-Type": "application/json" },
-        '[{ "id": ' + id + " }]"
+        '[{ "id": ' + id + " }]",
     );
 });
 ```

lib/configure-logger/index.js

@@ -5,13 +5,13 @@
 // https://github.com/cjohansen/Sinon.JS/issues/381
 var realSetTimeout = setTimeout;
 
 function configureLogger(config) {
     // eslint-disable-next-line no-param-reassign
     config = config || {};
     // Function which prints errors.
     if (!config.hasOwnProperty("logger")) {
         // eslint-disable-next-line no-empty-function
-        config.logger = function() {};
+        config.logger = function () {};
     }
     // When set to true, any errors logged will be thrown immediately;
     // If set to false, the errors will be thrown in separate execution frame.
@@ -28,10 +28,10 @@
         var err = {
             name: e.name || label,
             message: e.message || e.toString(),
-            stack: e.stack
+            stack: e.stack,
         };
 
         function throwLoggedError() {
             err.message = msg + err.message;
             throw err;
         }

lib/configure-logger/index.test.js

@@ -6,27 +6,27 @@ var sinon = require("sinon");
 
 var configureLogError = require("./index");
 
-describe("configureLogger", function() {
-    beforeEach(function() {
+describe("configureLogger", function () {
+    beforeEach(function () {
         this.sandbox = sinon.createSandbox();
         this.timeOutStub = this.sandbox.stub();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         this.sandbox.restore();
     });
 
-    it("is a function", function() {
+    it("is a function", function () {
         var instance = configureLogError();
         assert.isFunction(instance);
     });
 
-    it("calls config.logger function with a String", function() {
+    it("calls config.logger function with a String", function () {
         var spy = this.sandbox.spy();
         var logError = configureLogError({
             logger: spy,
             setTimeout: this.timeOutStub,
-            useImmediateExceptions: false
+            useImmediateExceptions: false,
         });
         var name = "Quisque consequat, elit id suscipit.";
         var message =
@@ -43,12 +43,12 @@ describe("configureLogger", function() {
         assert(spy.calledWithMatch(message));
     });
 
-    it("calls config.logger function with a stack", function() {
+    it("calls config.logger function with a stack", function () {
         var spy = this.sandbox.spy();
         var logError = configureLogError({
             logger: spy,
             setTimeout: this.timeOutStub,
-            useImmediateExceptions: false
+            useImmediateExceptions: false,
         });
         var stack =
             "Integer rutrum dictum elit, posuere accumsan nisi pretium vel. Phasellus adipiscing.";
@@ -62,10 +62,10 @@ describe("configureLogger", function() {
         assert(spy.calledWithMatch(stack));
     });
 
-    it("should call config.setTimeout", function() {
+    it("should call config.setTimeout", function () {
         var logError = configureLogError({
             setTimeout: this.timeOutStub,
-            useImmediateExceptions: false
+            useImmediateExceptions: false,
         });
         var error = new Error();
 
@@ -74,10 +74,10 @@ describe("configureLogger", function() {
         assert(this.timeOutStub.calledOnce);
     });
 
-    it("should pass a throwing function to config.setTimeout", function() {
+    it("should pass a throwing function to config.setTimeout", function () {
         var logError = configureLogError({
             setTimeout: this.timeOutStub,
-            useImmediateExceptions: false
+            useImmediateExceptions: false,
         });
         var error = new Error();
 
@@ -87,72 +87,72 @@ describe("configureLogger", function() {
         assert.exception(func);
     });
 
-    describe("config.useImmediateExceptions", function() {
-        beforeEach(function() {
+    describe("config.useImmediateExceptions", function () {
+        beforeEach(function () {
             this.sandbox = sinon.createSandbox();
             this.timeOutStub = this.sandbox.stub();
         });
 
-        afterEach(function() {
+        afterEach(function () {
             this.sandbox.restore();
         });
 
-        it("throws the logged error immediately, does not call logError.setTimeout when flag is true", function() {
+        it("throws the logged error immediately, does not call logError.setTimeout when flag is true", function () {
             var error = new Error();
             var logError = configureLogError({
                 setTimeout: this.timeOutStub,
-                useImmediateExceptions: true
+                useImmediateExceptions: true,
             });
 
-            assert.exception(function() {
+            assert.exception(function () {
                 logError("an error", error);
             });
             assert(this.timeOutStub.notCalled);
         });
 
-        it("does not throw logged error immediately and calls logError.setTimeout when flag is false", function() {
+        it("does not throw logged error immediately and calls logError.setTimeout when flag is false", function () {
             var error = new Error();
             var logError = configureLogError({
                 setTimeout: this.timeOutStub,
-                useImmediateExceptions: false
+                useImmediateExceptions: false,
             });
 
-            refute.exception(function() {
+            refute.exception(function () {
                 logError("an error", error);
             });
             assert(this.timeOutStub.called);
         });
     });
 
-    describe("#835", function() {
-        it("logError() throws an exception if the passed err is read-only", function() {
+    describe("#835", function () {
+        it("logError() throws an exception if the passed err is read-only", function () {
             var logError = configureLogError({ useImmediateExceptions: true });
 
             // passes
             var err = {
                 name: "TestError",
-                message: "this is a proper exception"
+                message: "this is a proper exception",
             };
             assert.exception(
-                function() {
+                function () {
                     logError("#835 test", err);
                 },
                 {
-                    name: err.name
-                }
+                    name: err.name,
+                },
             );
 
             // fails until this issue is fixed
             assert.exception(
-                function() {
+                function () {
                     logError(
                         "#835 test",
-                        "this literal string is not a proper exception"
+                        "this literal string is not a proper exception",
                     );
                 },
                 {
-                    name: "#835 test"
-                }
+                    name: "#835 test",
+                },
             );
         });
     });

lib/event/event-target.js

@@ -1,26 +1,26 @@
 "use strict";
 
 function flattenOptions(options) {
     if (options !== Object(options)) {
         return {
             capture: Boolean(options),
             once: false,
-            passive: false
+            passive: false,
         };
     }
     return {
         capture: Boolean(options.capture),
         once: Boolean(options.once),
-        passive: Boolean(options.passive)
+        passive: Boolean(options.passive),
     };
 }
 function not(fn) {
-    return function() {
+    return function () {
         return !fn.apply(this, arguments);
     };
 }
 function hasListenerFilter(listener, capture) {
-    return function(listenerSpec) {
+    return function (listenerSpec) {
         return (
             listenerSpec.capture === capture &&
             listenerSpec.listener === listener
@@ -33,7 +33,7 @@
     addEventListener: function addEventListener(
         event,
         listener,
-        providedOptions
+        providedOptions,
     ) {
         // 3. Let capture, passive, and once be the result of flattening more options.
         // Flatten property before executing step 2,
@@ -59,13 +59,13 @@
         //    callback, capture is capture, passive is passive, and once is once.
         if (
             !this.eventListeners[event].some(
-                hasListenerFilter(listener, options.capture)
+                hasListenerFilter(listener, options.capture),
             )
         ) {
             this.eventListeners[event].push({
                 listener: listener,
                 capture: options.capture,
-                once: options.once
+                once: options.once,
             });
         }
     },
@@ -74,7 +74,7 @@
     removeEventListener: function removeEventListener(
         event,
         listener,
-        providedOptions
+        providedOptions,
     ) {
         if (!this.eventListeners || !this.eventListeners[event]) {
             return;
@@ -88,7 +88,7 @@
         //    and capture is capture, then set that event listener’s
         //    removed to true and remove it from the associated list of event listeners.
         this.eventListeners[event] = this.eventListeners[event].filter(
-            not(hasListenerFilter(listener, options.capture))
+            not(hasListenerFilter(listener, options.capture)),
         );
     },
 
@@ -103,10 +103,10 @@
 
         // Remove listeners, that should be dispatched once
         // before running dispatch loop to avoid nested dispatch issues
-        self.eventListeners[type] = listeners.filter(function(listenerSpec) {
+        self.eventListeners[type] = listeners.filter(function (listenerSpec) {
             return !listenerSpec.once;
         });
-        listeners.forEach(function(listenerSpec) {
+        listeners.forEach(function (listenerSpec) {
             var listener = listenerSpec.listener;
             if (typeof listener === "function") {
                 listener.call(self, event);
@@ -116,7 +116,7 @@
         });
 
         return Boolean(event.defaultPrevented);
-    }
+    },
 };
 
 module.exports = EventTarget;

lib/event/event.js

@@ -1,11 +1,11 @@
 "use strict";
 
 function Event(type, bubbles, cancelable, target) {
     this.initEvent(type, bubbles, cancelable, target);
 }
 
 Event.prototype = {
-    initEvent: function(type, bubbles, cancelable, target) {
+    initEvent: function (type, bubbles, cancelable, target) {
         this.type = type;
         this.bubbles = bubbles;
         this.cancelable = cancelable;
@@ -14,11 +14,11 @@
     },
 
     // eslint-disable-next-line no-empty-function
-    stopPropagation: function() {},
+    stopPropagation: function () {},
 
-    preventDefault: function() {
+    preventDefault: function () {
         this.defaultPrevented = true;
-    }
+    },
 };
 
 module.exports = Event;

lib/event/index.js

@@ -4,5 +4,5 @@ module.exports = {
     Event: require("./event"),
     ProgressEvent: require("./progress-event"),
     CustomEvent: require("./custom-event"),
-    EventTarget: require("./event-target")
+    EventTarget: require("./event-target"),
 };