prettier

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,39 +4,45 @@ about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
-
 ---
 
 Issue tracker is **ONLY** used for reporting bugs. New features should be discussed on our Discord server.
 
-
 <!--- Provide a general summary of the issue in the Title above -->
 
 ## Expected Behavior
+
 <!--- Tell us what should happen -->
 
 ## Current Behavior
+
 <!--- Tell us what happens instead of the expected behavior -->
 
 ## Possible Solution
+
 <!--- Not obligatory, but suggest a fix/reason for the bug, -->
 
 ## Steps to Reproduce
+
 <!--- Provide a link to a live example, or an unambiguous set of steps to -->
 <!--- reproduce this bug. Include code to reproduce, if relevant -->
+
 1.
 2.
 3.
 4.
 
 ## Context (Environment)
+
 <!--- How has this issue affected you? What are you trying to accomplish? -->
 <!--- Providing context helps us come up with a solution that is most useful in the real world -->
 
 <!--- Provide a general summary of the issue in the Title above -->
 
 ## Detailed Description
+
 <!--- Provide a detailed description of the change or addition you are proposing -->
 
 ## Possible Implementation
+
 <!--- Not obligatory, but suggest an idea for implementing addition or change -->

.prettierrc

@@ -0,0 +1,4 @@
+{
+    "tabWidth": 4,
+    "singleQuote": true
+}

package-lock.json

@@ -22,6 +22,7 @@
                 "copy-webpack-plugin": "^11.0.0",
                 "cross-env": "^7.0.3",
                 "eslint": "^8.8.0",
+                "prettier": "^2.7.1",
                 "terser-webpack-plugin": "^5.3.6",
                 "webpack": "^5.74.0",
                 "webpack-cli": "^4.10.0"
@@ -1996,6 +1997,21 @@
                 "node": ">= 0.8.0"
             }
         },
+        "node_modules/prettier": {
+            "version": "2.7.1",
+            "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
+            "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
+            "dev": true,
+            "bin": {
+                "prettier": "bin-prettier.js"
+            },
+            "engines": {
+                "node": ">=10.13.0"
+            },
+            "funding": {
+                "url": "https://github.com/prettier/prettier?sponsor=1"
+            }
+        },
         "node_modules/punycode": {
             "version": "2.1.1",
             "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
@@ -4192,6 +4208,12 @@
             "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
             "dev": true
         },
+        "prettier": {
+            "version": "2.7.1",
+            "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
+            "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
+            "dev": true
+        },
         "punycode": {
             "version": "2.1.1",
             "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",

package.json

@@ -25,6 +25,7 @@
         "copy-webpack-plugin": "^11.0.0",
         "cross-env": "^7.0.3",
         "eslint": "^8.8.0",
+        "prettier": "^2.7.1",
         "terser-webpack-plugin": "^5.3.6",
         "webpack": "^5.74.0",
         "webpack-cli": "^4.10.0"

src/client/dom/attr.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class AttrApi extends EventEmitter {
     constructor(ctx) {
@@ -8,8 +8,14 @@ class AttrApi extends EventEmitter {
         this.window = ctx.window;
         this.Attr = this.window.Attr || {};
         this.attrProto = this.Attr.prototype || {};
-        this.value = ctx.nativeMethods.getOwnPropertyDescriptor(this.attrProto, 'value');
+        this.value = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.name = ctx.nativeMethods.getOwnPropertyDescriptor(this.attrProto, 'name');
+            this.attrProto,
+            'value'
+        );
+        this.name = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.attrProto,
+            'name'
+        );
         this.getNamedItem = this.attrProto.getNamedItem || null;
         this.setNamedItem = this.attrProto.setNamedItem || null;
         this.removeNamedItem = this.attrProto.removeNamedItem || null;
@@ -17,11 +23,15 @@ class AttrApi extends EventEmitter {
         this.setNamedItemNS = this.attrProto.setNamedItemNS || null;
         this.removeNamedItemNS = this.attrProto.removeNamedItemNS || null;
         this.item = this.attrProto.item || null;
-    };
+    }
     overrideNameValue() {
         this.ctx.overrideDescriptor(this.attrProto, 'name', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('name', event);
 
                 if (event.intercepted) return event.returnValue;
@@ -31,55 +41,82 @@ class AttrApi extends EventEmitter {
 
         this.ctx.overrideDescriptor(this.attrProto, 'value', {
             get: (target, that) => {
-                const event = new HookEvent({ name: this.name.get.call(that), value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    {
+                        name: this.name.get.call(that),
+                        value: target.call(that),
+                    },
+                    target,
+                    that
+                );
                 this.emit('getValue', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
-                const event = new HookEvent({ name: this.name.get.call(that), value: val }, target, that);
+                const event = new HookEvent(
+                    { name: this.name.get.call(that), value: val },
+                    target,
+                    that
+                );
                 this.emit('setValue', event);
 
                 if (event.intercepted) return event.returnValue;
                 event.target.call(event.that, event.data.value);
-            }
+            },
         });
-    };
+    }
     overrideItemMethods() {
-        this.ctx.override(this.attrProto, 'getNamedItem', (target, that, args) => {
+        this.ctx.override(
+            this.attrProto,
+            'getNamedItem',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
                 const event = new HookEvent({ name }, target, that);
                 this.emit('getNamedItem', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
-        this.ctx.override(this.attrProto, 'setNamedItem', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.attrProto,
+            'setNamedItem',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ name, value ] = args;
+                let [name, value] = args;
 
                 const event = new HookEvent({ name, value }, target, that);
                 this.emit('setNamedItem', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.name, event.data.value);
+                return event.target.call(
-        });
+                    event.that,
-        this.ctx.override(this.attrProto, 'removeNamedItem', (target, that, args) => {
+                    event.data.name,
+                    event.data.value
+                );
+            }
+        );
+        this.ctx.override(
+            this.attrProto,
+            'removeNamedItem',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
                 const event = new HookEvent({ name }, target, that);
                 this.emit('removeNamedItem', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
+        );
         this.ctx.override(this.attrProto, 'item', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ index ] = args;
+            let [index] = args;
 
             const event = new HookEvent({ index }, target, that);
             this.emit('item', event);
@@ -87,37 +124,65 @@ class AttrApi extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that, event.data.name);
         });
-        this.ctx.override(this.attrProto, 'getNamedItemNS', (target, that, args) => {
+        this.ctx.override(
+            this.attrProto,
+            'getNamedItemNS',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ namespace, localName ] = args;
+                let [namespace, localName] = args;
 
-            const event = new HookEvent({ namespace, localName }, target, that);
+                const event = new HookEvent(
+                    { namespace, localName },
+                    target,
+                    that
+                );
                 this.emit('getNamedItemNS', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.namespace, event.data.localName);
+                return event.target.call(
-        });
+                    event.that,
-        this.ctx.override(this.attrProto, 'setNamedItemNS', (target, that, args) => {
+                    event.data.namespace,
+                    event.data.localName
+                );
+            }
+        );
+        this.ctx.override(
+            this.attrProto,
+            'setNamedItemNS',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ attr ] = args;
+                let [attr] = args;
 
                 const event = new HookEvent({ attr }, target, that);
                 this.emit('setNamedItemNS', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
-        this.ctx.override(this.attrProto, 'removeNamedItemNS', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.attrProto,
+            'removeNamedItemNS',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ namespace, localName ] = args;
+                let [namespace, localName] = args;
 
-            const event = new HookEvent({ namespace, localName }, target, that);
+                const event = new HookEvent(
+                    { namespace, localName },
+                    target,
+                    that
+                );
                 this.emit('removeNamedItemNS', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.namespace, event.data.localName);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.namespace,
-};
+                    event.data.localName
+                );
+            }
+        );
+    }
+}
 
 export default AttrApi;

src/client/dom/document.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class DocumentHook extends EventEmitter {
     constructor(ctx) {
@@ -11,52 +11,86 @@ class DocumentHook extends EventEmitter {
         this.DOMParser = this.window.DOMParser || {};
         this.docProto = this.Document.prototype || {};
         this.domProto = this.DOMParser.prototype || {};
-        this.title = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'title');
+        this.title = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.cookie = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'cookie');
+            this.docProto,
-        this.referrer = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'referrer');
+            'title'
-        this.domain = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'domain');
+        );
-        this.documentURI = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'documentURI');
+        this.cookie = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.docProto,
+            'cookie'
+        );
+        this.referrer = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.docProto,
+            'referrer'
+        );
+        this.domain = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.docProto,
+            'domain'
+        );
+        this.documentURI = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.docProto,
+            'documentURI'
+        );
         this.write = this.docProto.write;
         this.writeln = this.docProto.writeln;
         this.querySelector = this.docProto.querySelector;
         this.querySelectorAll = this.docProto.querySelectorAll;
         this.parseFromString = this.domProto.parseFromString;
-        this.URL = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'URL');
+        this.URL = ctx.nativeMethods.getOwnPropertyDescriptor(
-    };
+            this.docProto,
+            'URL'
+        );
+    }
     overrideParseFromString() {
-        this.ctx.override(this.domProto, 'parseFromString', (target, that, args) => {
+        this.ctx.override(
+            this.domProto,
+            'parseFromString',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ string, type ] = args;
+                let [string, type] = args;
 
                 const event = new HookEvent({ string, type }, target, that);
                 this.emit('parseFromString', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.string, event.data.type);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.string,
+                    event.data.type
+                );
+            }
+        );
+    }
     overrideQuerySelector() {
-        this.ctx.override(this.docProto, 'querySelector', (target, that, args) => {
+        this.ctx.override(
+            this.docProto,
+            'querySelector',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ selectors ] = args;
+                let [selectors] = args;
 
                 const event = new HookEvent({ selectors }, target, that);
                 this.emit('querySelector', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.selectors);
-        }); 
+            }
-    };
+        );
+    }
     overrideDomain() {
         this.ctx.overrideDescriptor(this.docProto, 'domain', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getDomain', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
                 const event = new HookEvent({ value: val }, target, that);
                 this.emit('setDomain', event);
 
@@ -64,34 +98,53 @@ class DocumentHook extends EventEmitter {
                 return event.target.call(event.that, event.data.value);
             },
         });
-    };
+    }
     overrideReferrer() {
         this.ctx.overrideDescriptor(this.docProto, 'referrer', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('referrer', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
         });
-    };
+    }
     overrideCreateTreeWalker() {
-        this.ctx.override(this.docProto, 'createTreeWalker', (target, that, args) => {
+        this.ctx.override(
+            this.docProto,
+            'createTreeWalker',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ root, show = 0xFFFFFFFF, filter, expandEntityReferences ] = args;
+                let [root, show = 0xffffffff, filter, expandEntityReferences] =
+                    args;
 
-            const event = new HookEvent({ root, show, filter, expandEntityReferences }, target, that);
+                const event = new HookEvent(
+                    { root, show, filter, expandEntityReferences },
+                    target,
+                    that
+                );
                 this.emit('createTreeWalker', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.root, event.data.show, event.data.filter, event.data.expandEntityReferences);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.root,
+                    event.data.show,
+                    event.data.filter,
+                    event.data.expandEntityReferences
+                );
+            }
+        );
+    }
     overrideWrite() {
         this.ctx.override(this.docProto, 'write', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ ...html ] = args;
+            let [...html] = args;
 
             const event = new HookEvent({ html }, target, that);
             this.emit('write', event);
@@ -101,7 +154,7 @@ class DocumentHook extends EventEmitter {
         });
         this.ctx.override(this.docProto, 'writeln', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ ...html ] = args;
+            let [...html] = args;
 
             const event = new HookEvent({ html }, target, that);
             this.emit('writeln', event);
@@ -109,76 +162,96 @@ class DocumentHook extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.apply(event.that, event.data.html);
         });
-    };  
+    }
     overrideDocumentURI() {
         this.ctx.overrideDescriptor(this.docProto, 'documentURI', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('documentURI', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
         });
-    };
+    }
     overrideURL() {
         this.ctx.overrideDescriptor(this.docProto, 'URL', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('url', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
         });
-    };
+    }
     overrideReferrer() {
         this.ctx.overrideDescriptor(this.docProto, 'referrer', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('referrer', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
         });
-    };
+    }
     overrideCookie() {
         this.ctx.overrideDescriptor(this.docProto, 'cookie', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getCookie', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ value ]) => {
+            set: (target, that, [value]) => {
-                const event = new HookEvent({ value, }, target, that);
+                const event = new HookEvent({ value }, target, that);
                 this.emit('setCookie', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.value);
             },
         });
-    };
+    }
     overrideTitle() {
         this.ctx.overrideDescriptor(this.docProto, 'title', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getTitle', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ value ]) => {
+            set: (target, that, [value]) => {
-                const event = new HookEvent({ value, }, target, that);
+                const event = new HookEvent({ value }, target, that);
                 this.emit('setTitle', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.value);
             },
         });
-    };
+    }
-};
+}
 
 export default DocumentHook;

src/client/dom/element.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class ElementApi extends EventEmitter {
     constructor(ctx) {
@@ -9,8 +9,14 @@ class ElementApi extends EventEmitter {
         this.Audio = this.window.Audio;
         this.Element = this.window.Element;
         this.elemProto = this.Element ? this.Element.prototype : {};
-        this.innerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(this.elemProto, 'innerHTML');
+        this.innerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.outerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(this.elemProto, 'outerHTML');
+            this.elemProto,
+            'innerHTML'
+        );
+        this.outerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.elemProto,
+            'outerHTML'
+        );
         this.setAttribute = this.elemProto.setAttribute;
         this.getAttribute = this.elemProto.getAttribute;
         this.removeAttribute = this.elemProto.removeAttribute;
@@ -19,83 +25,116 @@ class ElementApi extends EventEmitter {
         this.querySelectorAll = this.elemProto.querySelectorAll;
         this.insertAdjacentHTML = this.elemProto.insertAdjacentHTML;
         this.insertAdjacentText = this.elemProto.insertAdjacentText;
-    };
+    }
     overrideQuerySelector() {
-        this.ctx.override(this.elemProto, 'querySelector', (target, that, args) => {
+        this.ctx.override(
+            this.elemProto,
+            'querySelector',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ selectors ] = args;
+                let [selectors] = args;
 
                 const event = new HookEvent({ selectors }, target, that);
                 this.emit('querySelector', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.selectors);
-        }); 
+            }
-    };
+        );
+    }
     overrideAttribute() {
-        this.ctx.override(this.elemProto, 'getAttribute', (target, that, args) => {
+        this.ctx.override(
+            this.elemProto,
+            'getAttribute',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
                 const event = new HookEvent({ name }, target, that);
                 this.emit('getAttribute', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
-        this.ctx.override(this.elemProto, 'setAttribute', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.elemProto,
+            'setAttribute',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ name, value ] = args;
+                let [name, value] = args;
 
                 const event = new HookEvent({ name, value }, target, that);
                 this.emit('setAttribute', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.name, event.data.value);
+                return event.target.call(
-        });
+                    event.that,
-        this.ctx.override(this.elemProto, 'hasAttribute', (target, that, args) => {
+                    event.data.name,
+                    event.data.value
+                );
+            }
+        );
+        this.ctx.override(
+            this.elemProto,
+            'hasAttribute',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
                 const event = new HookEvent({ name }, target, that);
                 this.emit('hasAttribute', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
-        this.ctx.override(this.elemProto, 'removeAttribute', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.elemProto,
+            'removeAttribute',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
                 const event = new HookEvent({ name }, target, that);
                 this.emit('removeAttribute', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
-    };
+        );
+    }
     overrideAudio() {
-        this.ctx.override(this.window, 'Audio', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'Audio',
+            (target, that, args) => {
                 if (!args.length) return new target(...args);
-            let [ url ] = args;
+                let [url] = args;
 
                 const event = new HookEvent({ url }, target, that);
                 this.emit('audio', event);
 
                 if (event.intercepted) return event.returnValue;
                 return new event.target(event.data.url);
-        }, true);
+            },
-    };
+            true
+        );
+    }
     overrideHtml() {
         this.hookProperty(this.Element, 'innerHTML', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getInnerHTML', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
                 const event = new HookEvent({ value: val }, target, that);
                 this.emit('setInnerHTML', event);
 
@@ -105,13 +144,17 @@ class ElementApi extends EventEmitter {
         });
         this.hookProperty(this.Element, 'outerHTML', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getOuterHTML', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
                 const event = new HookEvent({ value: val }, target, that);
                 this.emit('setOuterHTML', event);
 
@@ -119,47 +162,63 @@ class ElementApi extends EventEmitter {
                 target.call(that, event.data.value);
             },
         });
-    };
+    }
     overrideInsertAdjacentHTML() {
-        this.ctx.override(this.elemProto, 'insertAdjacentHTML', (target, that, args) => {
+        this.ctx.override(
+            this.elemProto,
+            'insertAdjacentHTML',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ position, html ] = args;
+                let [position, html] = args;
 
                 const event = new HookEvent({ position, html }, target, that);
                 this.emit('insertAdjacentHTML', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.position, event.data.html);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.position,
+                    event.data.html
+                );
+            }
+        );
+    }
     overrideInsertAdjacentText() {
-        this.ctx.override(this.elemProto, 'insertAdjacentText', (target, that, args) => {
+        this.ctx.override(
+            this.elemProto,
+            'insertAdjacentText',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ position, text ] = args;
+                let [position, text] = args;
 
                 const event = new HookEvent({ position, text }, target, that);
                 this.emit('insertAdjacentText', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.position, event.data.text);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.position,
+                    event.data.text
+                );
+            }
+        );
+    }
     hookProperty(element, prop, handler) {
         if (!element || !prop in element) return false;
 
         if (this.ctx.nativeMethods.isArray(element)) {
             for (const elem of element) {
                 this.hookProperty(elem, prop, handler);
-            };
+            }
             return true;
-        };
+        }
 
         const proto = element.prototype;
 
         this.ctx.overrideDescriptor(proto, prop, handler);
 
         return true;
-    };
+    }
-};
+}
 
 export default ElementApi;

src/client/dom/node.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class NodeApi extends EventEmitter {
     constructor(ctx) {
@@ -16,24 +16,49 @@ class NodeApi extends EventEmitter {
         this.appendChild = this.nodeProto.appendChild;
         this.removeChild = this.nodeProto.removeChild;
 
-        this.textContent = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'textContent');
+        this.textContent = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.parentNode = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'parentNode');
+            this.nodeProto,
-        this.parentElement = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'parentElement');
+            'textContent'
-        this.childNodes = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'childNodes');
+        );
-        this.baseURI = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'baseURI');
+        this.parentNode = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.previousSibling = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'previousSibling');
+            this.nodeProto,
-        this.ownerDocument = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'ownerDocument');
+            'parentNode'
-    };
+        );
+        this.parentElement = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.nodeProto,
+            'parentElement'
+        );
+        this.childNodes = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.nodeProto,
+            'childNodes'
+        );
+        this.baseURI = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.nodeProto,
+            'baseURI'
+        );
+        this.previousSibling = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.nodeProto,
+            'previousSibling'
+        );
+        this.ownerDocument = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.nodeProto,
+            'ownerDocument'
+        );
+    }
     overrideTextContent() {
         this.ctx.overrideDescriptor(this.nodeProto, 'textContent', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getTextContent', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
                 const event = new HookEvent({ value: val }, target, that);
                 this.emit('setTextContent', event);
 
@@ -41,41 +66,57 @@ class NodeApi extends EventEmitter {
                 target.call(that, event.data.value);
             },
         });
-    };
+    }
     overrideAppend() {
-        this.ctx.override(this.nodeProto, 'append', (target, that, [ ...nodes ]) => {
+        this.ctx.override(
+            this.nodeProto,
+            'append',
+            (target, that, [...nodes]) => {
                 const event = new HookEvent({ nodes }, target, that);
                 this.emit('append', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.nodes);
-        });
+            }
-        this.ctx.override(this.nodeProto, 'appendChild', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.nodeProto,
+            'appendChild',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ node ] = args;
+                let [node] = args;
 
                 const event = new HookEvent({ node }, target, that);
                 this.emit('appendChild', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.node);
-        });
+            }
-    };
+        );
+    }
     overrideBaseURI() {
         this.ctx.overrideDescriptor(this.nodeProto, 'baseURI', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('baseURI', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-        })
+        });
-    };
+    }
     overrideParent() {
         this.ctx.overrideDescriptor(this.nodeProto, 'parentNode', {
             get: (target, that) => {
-                const event = new HookEvent({ node: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { node: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('parentNode', event);
 
                 if (event.intercepted) return event.returnValue;
@@ -84,38 +125,50 @@ class NodeApi extends EventEmitter {
         });
         this.ctx.overrideDescriptor(this.nodeProto, 'parentElement', {
             get: (target, that) => {
-                const event = new HookEvent({ element: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { element: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('parentElement', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.node;
             },
         });
-    };
+    }
     overrideOwnerDocument() {
         this.ctx.overrideDescriptor(this.nodeProto, 'ownerDocument', {
             get: (target, that) => {
-                const event = new HookEvent({ document: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { document: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('ownerDocument', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.document;
             },
         });
-    };
+    }
     overrideCompareDocumentPosit1ion() {
-        this.ctx.override(this.nodeProto, 'compareDocumentPosition', (target, that, args) => {
+        this.ctx.override(
+            this.nodeProto,
+            'compareDocumentPosition',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ node ] = args;
+                let [node] = args;
                 const event = new HookEvent({ node }, target, that);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.node);
-        });
+            }
-    };
+        );
+    }
     overrideChildMethods() {
-        this.ctx.override(this.nodeProto, 'removeChild')
+        this.ctx.override(this.nodeProto, 'removeChild');
-    };
+    }
-};  
+}
 
 export default NodeApi;

src/client/dom/style.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class StyleApi extends EventEmitter {
     constructor(ctx) {
@@ -10,9 +10,29 @@ class StyleApi extends EventEmitter {
         this.cssStyleProto = this.CSSStyleDeclaration.prototype || {};
         this.getPropertyValue = this.cssStyleProto.getPropertyValue || null;
         this.setProperty = this.cssStyleProto.setProperty || null;
-        this.cssText - ctx.nativeMethods.getOwnPropertyDescriptors(this.cssStyleProto, 'cssText');
+        this.cssText -
-        this.urlProps = ['background', 'backgroundImage', 'borderImage', 'borderImageSource', 'listStyle', 'listStyleImage', 'cursor'];
+            ctx.nativeMethods.getOwnPropertyDescriptors(
-        this.dashedUrlProps = ['background', 'background-image', 'border-image', 'border-image-source', 'list-style', 'list-style-image', 'cursor'];
+                this.cssStyleProto,
+                'cssText'
+            );
+        this.urlProps = [
+            'background',
+            'backgroundImage',
+            'borderImage',
+            'borderImageSource',
+            'listStyle',
+            'listStyleImage',
+            'cursor',
+        ];
+        this.dashedUrlProps = [
+            'background',
+            'background-image',
+            'border-image',
+            'border-image-source',
+            'list-style',
+            'list-style-image',
+            'cursor',
+        ];
         this.propToDashed = {
             background: 'background',
             backgroundImage: 'background-image',
@@ -20,42 +40,58 @@ class StyleApi extends EventEmitter {
             borderImageSource: 'border-image-source',
             listStyle: 'list-style',
             listStyleImage: 'list-style-image',
-            cursor: 'cursor'
+            cursor: 'cursor',
-        };
         };
+    }
     overrideSetGetProperty() {
-        this.ctx.override(this.cssStyleProto, 'getPropertyValue', (target, that, args) => {
+        this.ctx.override(
+            this.cssStyleProto,
+            'getPropertyValue',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
 
-            let [ property ] = args;
+                let [property] = args;
 
                 const event = new HookEvent({ property }, target, that);
                 this.emit('getPropertyValue', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.property);
-        });
+            }
-        this.ctx.override(this.cssStyleProto, 'setProperty', (target, that, args) => {
+        );
+        this.ctx.override(
+            this.cssStyleProto,
+            'setProperty',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ property, value ] = args;
+                let [property, value] = args;
 
                 const event = new HookEvent({ property, value }, target, that);
                 this.emit('setProperty', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.property, event.data.value);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.property,
+                    event.data.value
+                );
+            }
+        );
+    }
     overrideCssText() {
         this.ctx.overrideDescriptor(this.cssStyleProto, 'cssText', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('getCssText', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
-            set: (target, that, [ val ]) => {
+            set: (target, that, [val]) => {
                 const event = new HookEvent({ value: val }, target, that);
                 this.emit('setCssText', event);
 
@@ -63,7 +99,7 @@ class StyleApi extends EventEmitter {
                 return event.target.call(event.that, event.data.value);
             },
         });
-    };
+    }
-};
+}
 
 export default StyleApi;

src/client/events.js

@@ -21,20 +21,22 @@
 
 'use strict';
 
-var R = typeof Reflect === 'object' ? Reflect : null
+var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function'
+var ReflectApply =
+    R && typeof R.apply === 'function'
         ? R.apply
         : function ReflectApply(target, receiver, args) {
               return Function.prototype.apply.call(target, receiver, args);
-  }
+          };
 
-var ReflectOwnKeys
+var ReflectOwnKeys;
 if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
+    ReflectOwnKeys = R.ownKeys;
 } else if (Object.getOwnPropertySymbols) {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
+        return Object.getOwnPropertyNames(target).concat(
-      .concat(Object.getOwnPropertySymbols(target));
+            Object.getOwnPropertySymbols(target)
+        );
     };
 } else {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
@@ -46,9 +48,11 @@ function ProcessEmitWarning(warning) {
     if (console && console.warn) console.warn(warning);
 }
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+var NumberIsNaN =
+    Number.isNaN ||
+    function NumberIsNaN(value) {
         return value !== value;
-}
+    };
 
 function EventEmitter() {
     EventEmitter.init.call(this);
@@ -69,27 +73,35 @@ var defaultMaxListeners = 10;
 
 function checkListener(listener) {
     if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+        throw new TypeError(
+            'The "listener" argument must be of type Function. Received type ' +
+                typeof listener
+        );
     }
 }
 
 Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
     enumerable: true,
-  get: function() {
+    get: function () {
         return defaultMaxListeners;
     },
-  set: function(arg) {
+    set: function (arg) {
         if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+            throw new RangeError(
+                'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
+                    arg +
+                    '.'
+            );
         }
         defaultMaxListeners = arg;
-  }
+    },
 });
 
-EventEmitter.init = function() {
+EventEmitter.init = function () {
-
+    if (
-  if (this._events === undefined ||
+        this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
+        this._events === Object.getPrototypeOf(this)._events
+    ) {
         this._events = Object.create(null);
         this._eventsCount = 0;
     }
@@ -101,7 +113,11 @@ EventEmitter.init = function() {
 // that to be increased. Set to zero for unlimited.
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
     if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+        throw new RangeError(
+            'The value of "n" is out of range. It must be a non-negative number. Received ' +
+                n +
+                '.'
+        );
     }
     this._maxListeners = n;
     return this;
@@ -120,42 +136,39 @@ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
 EventEmitter.prototype.emit = function emit(type) {
     var args = [];
     for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+    var doError = type === 'error';
 
     var events = this._events;
-  if (events !== undefined)
+    if (events !== undefined) doError = doError && events.error === undefined;
-    doError = (doError && events.error === undefined);
+    else if (!doError) return false;
-  else if (!doError)
-    return false;
 
     // If there is no 'error' event listener then throw.
     if (doError) {
         var er;
-    if (args.length > 0)
+        if (args.length > 0) er = args[0];
-      er = args[0];
         if (er instanceof Error) {
             // Note: The comments on the `throw` lines are intentional, they show
             // up in Node's output if this results in an unhandled exception.
             throw er; // Unhandled 'error' event
         }
         // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+        var err = new Error(
+            'Unhandled error.' + (er ? ' (' + er.message + ')' : '')
+        );
         err.context = er;
         throw err; // Unhandled 'error' event
     }
 
     var handler = events[type];
 
-  if (handler === undefined)
+    if (handler === undefined) return false;
-    return false;
 
     if (typeof handler === 'function') {
         ReflectApply(handler, this, args);
     } else {
         var len = handler.length;
         var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
+        for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
-      ReflectApply(listeners[i], this, args);
     }
 
     return true;
@@ -176,8 +189,11 @@ function _addListener(target, type, listener, prepend) {
         // To avoid recursion in the case that type === "newListener"! Before
         // adding it to the listeners, first emit "newListener".
         if (events.newListener !== undefined) {
-      target.emit('newListener', type,
+            target.emit(
-                  listener.listener ? listener.listener : listener);
+                'newListener',
+                type,
+                listener.listener ? listener.listener : listener
+            );
 
             // Re-assign `events` because a newListener handler could have caused the
             // this._events to be assigned to a new object
@@ -193,8 +209,9 @@ function _addListener(target, type, listener, prepend) {
     } else {
         if (typeof existing === 'function') {
             // Adding the second element, need to change to array.
-      existing = events[type] =
+            existing = events[type] = prepend
-        prepend ? [listener, existing] : [existing, listener];
+                ? [listener, existing]
+                : [existing, listener];
             // If we've already got an array, just append.
         } else if (prepend) {
             existing.unshift(listener);
@@ -208,10 +225,15 @@ function _addListener(target, type, listener, prepend) {
             existing.warned = true;
             // No error code for this since it is a Warning
             // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
+            var w = new Error(
-                          existing.length + ' ' + String(type) + ' listeners ' +
+                'Possible EventEmitter memory leak detected. ' +
+                    existing.length +
+                    ' ' +
+                    String(type) +
+                    ' listeners ' +
                     'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
+                    'increase limit'
+            );
             w.name = 'MaxListenersExceededWarning';
             w.emitter = target;
             w.type = type;
@@ -229,23 +251,30 @@ EventEmitter.prototype.addListener = function addListener(type, listener) {
 
 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-EventEmitter.prototype.prependListener =
+EventEmitter.prototype.prependListener = function prependListener(
-    function prependListener(type, listener) {
+    type,
+    listener
+) {
     return _addListener(this, type, listener, true);
-    };
+};
 
 function onceWrapper() {
     if (!this.fired) {
         this.target.removeListener(this.type, this.wrapFn);
         this.fired = true;
-    if (arguments.length === 0)
+        if (arguments.length === 0) return this.listener.call(this.target);
-      return this.listener.call(this.target);
         return this.listener.apply(this.target, arguments);
     }
 }
 
 function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var state = {
+        fired: false,
+        wrapFn: undefined,
+        target: target,
+        type: type,
+        listener: listener,
+    };
     var wrapped = onceWrapper.bind(state);
     wrapped.listener = listener;
     state.wrapFn = wrapped;
@@ -258,31 +287,32 @@ EventEmitter.prototype.once = function once(type, listener) {
     return this;
 };
 
-EventEmitter.prototype.prependOnceListener =
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(
-    function prependOnceListener(type, listener) {
+    type,
+    listener
+) {
     checkListener(listener);
     this.prependListener(type, _onceWrap(this, type, listener));
     return this;
-    };
+};
 
 // Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
+EventEmitter.prototype.removeListener = function removeListener(
-    function removeListener(type, listener) {
+    type,
+    listener
+) {
     var list, events, position, i, originalListener;
 
     checkListener(listener);
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     list = events[type];
-      if (list === undefined)
+    if (list === undefined) return this;
-        return this;
 
     if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
+        if (--this._eventsCount === 0) this._events = Object.create(null);
-          this._events = Object.create(null);
         else {
             delete events[type];
             if (events.removeListener)
@@ -299,34 +329,29 @@ EventEmitter.prototype.removeListener =
             }
         }
 
-        if (position < 0)
+        if (position < 0) return this;
-          return this;
 
-        if (position === 0)
+        if (position === 0) list.shift();
-          list.shift();
         else {
             spliceOne(list, position);
         }
 
-        if (list.length === 1)
+        if (list.length === 1) events[type] = list[0];
-          events[type] = list[0];
 
         if (events.removeListener !== undefined)
             this.emit('removeListener', type, originalListener || listener);
     }
 
     return this;
-    };
+};
 
 EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners =
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-    function removeAllListeners(type) {
     var listeners, events, i;
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     // not listening for removeListener, no need to emit
     if (events.removeListener === undefined) {
@@ -334,10 +359,8 @@ EventEmitter.prototype.removeAllListeners =
             this._events = Object.create(null);
             this._eventsCount = 0;
         } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
+            if (--this._eventsCount === 0) this._events = Object.create(null);
-            this._events = Object.create(null);
+            else delete events[type];
-          else
-            delete events[type];
         }
         return this;
     }
@@ -369,23 +392,22 @@ EventEmitter.prototype.removeAllListeners =
     }
 
     return this;
-    };
+};
 
 function _listeners(target, type, unwrap) {
     var events = target._events;
 
-  if (events === undefined)
+    if (events === undefined) return [];
-    return [];
 
     var evlistener = events[type];
-  if (evlistener === undefined)
+    if (evlistener === undefined) return [];
-    return [];
 
     if (typeof evlistener === 'function')
         return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
-  return unwrap ?
+    return unwrap
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+        ? unwrapListeners(evlistener)
+        : arrayClone(evlistener, evlistener.length);
 }
 
 EventEmitter.prototype.listeners = function listeners(type) {
@@ -396,7 +418,7 @@ EventEmitter.prototype.rawListeners = function rawListeners(type) {
     return _listeners(this, type, false);
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
+EventEmitter.listenerCount = function (emitter, type) {
     if (typeof emitter.listenerCount === 'function') {
         return emitter.listenerCount(type);
     } else {
@@ -427,14 +449,12 @@ EventEmitter.prototype.eventNames = function eventNames() {
 
 function arrayClone(arr, n) {
     var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
+    for (var i = 0; i < n; ++i) copy[i] = arr[i];
-    copy[i] = arr[i];
     return copy;
 }
 
 function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
+    for (; index + 1 < list.length; index++) list[index] = list[index + 1];
-    list[index] = list[index + 1];
     list.pop();
 }
 
@@ -458,11 +478,13 @@ function once(emitter, name) {
                 emitter.removeListener('error', errorListener);
             }
             resolve([].slice.call(arguments));
-    };
+        }
 
         eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
         if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+            addErrorHandlerIfEventEmitter(emitter, errorListener, {
+                once: true,
+            });
         }
     });
 }
@@ -492,6 +514,9 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
             listener(arg);
         });
     } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+        throw new TypeError(
+            'The "emitter" argument must be of type EventEmitter. Received type ' +
+                typeof emitter
+        );
     }
 }

src/client/history.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class History extends EventEmitter {
     constructor(ctx) {
@@ -14,47 +14,73 @@ class History extends EventEmitter {
         this.go = this.historyProto.go;
         this.back = this.historyProto.back;
         this.forward = this.historyProto.forward;
-    };
+    }
     override() {
         this.overridePushState();
         this.overrideReplaceState();
         this.overrideGo();
         this.overrideForward();
         this.overrideBack();
-    };
+    }
     overridePushState() {
-        this.ctx.override(this.historyProto, 'pushState', (target, that, args) => {
+        this.ctx.override(
+            this.historyProto,
+            'pushState',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ state, title, url = '' ] = args;
+                let [state, title, url = ''] = args;
 
-            const event = new HookEvent({ state, title, url }, target, that);
+                const event = new HookEvent(
+                    { state, title, url },
+                    target,
+                    that
+                );
                 this.emit('pushState', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.state, event.data.title, event.data.url);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.state,
+                    event.data.title,
+                    event.data.url
+                );
+            }
+        );
+    }
     overrideReplaceState() {
-        this.ctx.override(this.historyProto, 'replaceState', (target, that, args) => {
+        this.ctx.override(
+            this.historyProto,
+            'replaceState',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
-            let [ state, title, url = '' ] = args;
+                let [state, title, url = ''] = args;
 
-            const event = new HookEvent({ state, title, url }, target, that);
+                const event = new HookEvent(
+                    { state, title, url },
+                    target,
+                    that
+                );
                 this.emit('replaceState', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.state, event.data.title, event.data.url);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.state,
+                    event.data.title,
+                    event.data.url
+                );
+            }
+        );
+    }
     overrideGo() {
-        this.ctx.override(this.historyProto, 'go', (target, that, [ delta ]) => {
+        this.ctx.override(this.historyProto, 'go', (target, that, [delta]) => {
             const event = new HookEvent({ delta }, target, that);
             this.emit('go', event);
 
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that, event.data.delta);
         });
-    };
+    }
     overrideForward() {
         this.ctx.override(this.historyProto, 'forward', (target, that) => {
             const event = new HookEvent(null, target, that);
@@ -63,7 +89,7 @@ class History extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that);
         });
-    };
+    }
     overrideBack() {
         this.ctx.override(this.historyProto, 'back', (target, that) => {
             const event = new HookEvent(null, target, that);
@@ -72,7 +98,7 @@ class History extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that);
         });
-    };
+    }
-};
+}
 
 export default History;

src/client/hook.js

@@ -7,17 +7,17 @@ class HookEvent {
         this.data = data;
         this.target = target;
         this.that = that;
-    };
+    }
     get intercepted() {
         return this.#intercepted;
-    };
+    }
     get returnValue() {
         return this.#returnValue;
-    };
+    }
     respondWith(input) {
         this.#returnValue = input;
         this.#intercepted = true;
-    };
+    }
-};  
+}
 
 export default HookEvent;

src/client/index.js

@@ -1,22 +1,22 @@
-import DocumentHook from "./dom/document.js";
+import DocumentHook from './dom/document.js';
-import ElementApi from "./dom/element.js";
+import ElementApi from './dom/element.js';
-import NodeApi from "./dom/node.js";
+import NodeApi from './dom/node.js';
-import AttrApi from "./dom/attr.js";
+import AttrApi from './dom/attr.js';
-import FunctionHook from "./native/function.js";
+import FunctionHook from './native/function.js';
-import ObjectHook from "./native/object.js";
+import ObjectHook from './native/object.js';
-import Fetch from "./requests/fetch.js";
+import Fetch from './requests/fetch.js';
-import WebSocketApi from "./requests/websocket.js";
+import WebSocketApi from './requests/websocket.js';
-import Xhr from "./requests/xhr.js";
+import Xhr from './requests/xhr.js';
-import EventSourceApi from "./requests/eventsource.js";
+import EventSourceApi from './requests/eventsource.js';
-import History from "./history.js";
+import History from './history.js';
-import LocationApi from "./location.js";
+import LocationApi from './location.js';
-import MessageApi from "./message.js";
+import MessageApi from './message.js';
-import NavigatorApi from "./navigator.js";
+import NavigatorApi from './navigator.js';
-import Workers from "./worker.js";
+import Workers from './worker.js';
-import URLApi from "./url.js";
+import URLApi from './url.js';
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import StorageApi from "./storage.js";
+import StorageApi from './storage.js';
-import StyleApi from "./dom/style.js";
+import StyleApi from './dom/style.js';
 
 class UVClient extends EventEmitter {
     constructor(window = self, worker = !window.window) {
@@ -25,8 +25,10 @@ class UVClient extends EventEmitter {
         this.nativeMethods = {
             fnToString: this.window.Function.prototype.toString,
             defineProperty: this.window.Object.defineProperty,
-            getOwnPropertyDescriptor: this.window.Object.getOwnPropertyDescriptor,
+            getOwnPropertyDescriptor:
-            getOwnPropertyDescriptors: this.window.Object.getOwnPropertyDescriptors,
+                this.window.Object.getOwnPropertyDescriptor,
+            getOwnPropertyDescriptors:
+                this.window.Object.getOwnPropertyDescriptors,
             getOwnPropertyNames: this.window.Object.getOwnPropertyNames,
             keys: this.window.Object.keys,
             getOwnPropertySymbols: this.window.Object.getOwnPropertySymbols,
@@ -41,7 +43,7 @@ class UVClient extends EventEmitter {
         this.xhr = new Xhr(this);
         this.history = new History(this);
         this.element = new ElementApi(this);
-        this.node = new NodeApi(this)
+        this.node = new NodeApi(this);
         this.document = new DocumentHook(this);
         this.function = new FunctionHook(this);
         this.object = new ObjectHook(this);
@@ -55,27 +57,35 @@ class UVClient extends EventEmitter {
         this.location = new LocationApi(this);
         this.storage = new StorageApi(this);
         this.style = new StyleApi(this);
-    };
+    }
     initLocation(rewriteUrl, sourceUrl) {
-        this.location = new LocationApi(this, sourceUrl, rewriteUrl, this.worker);
+        this.location = new LocationApi(
-    };
+            this,
+            sourceUrl,
+            rewriteUrl,
+            this.worker
+        );
+    }
     override(obj, prop, wrapper, construct) {
         if (!prop in obj) return false;
         const wrapped = this.wrap(obj, prop, wrapper, construct);
-        return obj[prop] = wrapped;
+        return (obj[prop] = wrapped);
-    };
+    }
     overrideDescriptor(obj, prop, wrapObj = {}) {
         const wrapped = this.wrapDescriptor(obj, prop, wrapObj);
         if (!wrapped) return {};
         this.nativeMethods.defineProperty(obj, prop, wrapped);
         return wrapped;
-    };
+    }
     wrap(obj, prop, wrap, construct) {
         const fn = obj[prop];
         if (!fn) return fn;
-        const wrapped = 'prototype' in fn ? function attach() {
+        const wrapped =
+            'prototype' in fn
+                ? function attach() {
                       return wrap(fn, this, [...arguments]);
-        } : {
+                  }
+                : {
                       attach() {
                           return wrap(fn, this, [...arguments]);
                       },
@@ -84,27 +94,33 @@ class UVClient extends EventEmitter {
         if (!!construct) {
             wrapped.prototype = fn.prototype;
             wrapped.prototype.constructor = wrapped;
-        };
+        }
 
         this.emit('wrap', fn, wrapped, !!construct);
 
         return wrapped;
-    };
+    }
     wrapDescriptor(obj, prop, wrapObj = {}) {
-        const descriptor = this.nativeMethods.getOwnPropertyDescriptor(obj, prop);
+        const descriptor = this.nativeMethods.getOwnPropertyDescriptor(
+            obj,
+            prop
+        );
         if (!descriptor) return false;
         for (let key in wrapObj) {
             if (key in descriptor) {
                 if (key === 'get' || key === 'set') {
                     descriptor[key] = this.wrap(descriptor, key, wrapObj[key]);
                 } else {
-                    descriptor[key] = typeof wrapObj[key] == 'function' ? wrapObj[key](descriptor[key]) : wrapObj[key];
+                    descriptor[key] =
-                };
+                        typeof wrapObj[key] == 'function'
+                            ? wrapObj[key](descriptor[key])
+                            : wrapObj[key];
+                }
+            }
         }
-        };
         return descriptor;
-    };
+    }
-};
+}
 
 export default UVClient;
 if (typeof self === 'object') self.UVClient = UVClient;

src/client/location.js

@@ -1,4 +1,4 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
 
 class LocationApi extends EventEmitter {
     constructor(ctx) {
@@ -6,13 +6,31 @@ class LocationApi extends EventEmitter {
         this.ctx = ctx;
         this.window = ctx.window;
         this.location = this.window.location;
-        this.WorkerLocation = this.ctx.worker ? this.window.WorkerLocation : null;
+        this.WorkerLocation = this.ctx.worker
-        this.workerLocProto = this.WorkerLocation ? this.WorkerLocation.prototype : {};
+            ? this.window.WorkerLocation
-        this.keys = ['href', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash', 'origin'];
+            : null;
+        this.workerLocProto = this.WorkerLocation
+            ? this.WorkerLocation.prototype
+            : {};
+        this.keys = [
+            'href',
+            'protocol',
+            'host',
+            'hostname',
+            'port',
+            'pathname',
+            'search',
+            'hash',
+            'origin',
+        ];
         this.HashChangeEvent = this.window.HashChangeEvent || null;
-        this.href = this.WorkerLocation ? ctx.nativeMethods.getOwnPropertyDescriptor(this.workerLocProto, 'href') : 
+        this.href = this.WorkerLocation
-        ctx.nativeMethods.getOwnPropertyDescriptor(this.location, 'href');
+            ? ctx.nativeMethods.getOwnPropertyDescriptor(
-    };
+                  this.workerLocProto,
+                  'href'
+              )
+            : ctx.nativeMethods.getOwnPropertyDescriptor(this.location, 'href');
+    }
     overrideWorkerLocation(parse) {
         if (!this.WorkerLocation) return false;
         const uv = this;
@@ -20,15 +38,13 @@ class LocationApi extends EventEmitter {
         for (const key of this.keys) {
             this.ctx.overrideDescriptor(this.workerLocProto, key, {
                 get: (target, that) => {
-                    return parse(
+                    return parse(uv.href.get.call(this.location))[key];
-                        uv.href.get.call(this.location)
-                    )[key]
                 },
             });
-        };
+        }
 
         return true;
-    };
+    }
     emulate(parse, wrap) {
         const emulation = {};
         const that = this;
@@ -36,81 +52,124 @@ class LocationApi extends EventEmitter {
         for (const key of that.keys) {
             this.ctx.nativeMethods.defineProperty(emulation, key, {
                 get() {
-                    return parse(
+                    return parse(that.href.get.call(that.location))[key];
-                        that.href.get.call(that.location)
-                    )[key];
                 },
-                set: key !== 'origin' ? function (val) {
+                set:
-                    switch(key) {
+                    key !== 'origin'
+                        ? function (val) {
+                              switch (key) {
                                   case 'href':
                                       that.location.href = wrap(val);
                                       break;
                                   case 'hash':
-                            that.emit('hashchange', emulation.href, (val.trim().startsWith('#') ? new URL(val.trim(), emulation.href).href : new URL('#' + val.trim(), emulation.href).href), that);
+                                      that.emit(
+                                          'hashchange',
+                                          emulation.href,
+                                          val.trim().startsWith('#')
+                                              ? new URL(
+                                                    val.trim(),
+                                                    emulation.href
+                                                ).href
+                                              : new URL(
+                                                    '#' + val.trim(),
+                                                    emulation.href
+                                                ).href,
+                                          that
+                                      );
                                       break;
                                   default:
                                       const url = new URL(emulation.href);
                                       url[key] = val;
                                       that.location.href = wrap(url.href);
-                    };
+                              }
-                } : undefined,
+                          }
+                        : undefined,
                 configurable: false,
                 enumerable: true,
             });
-        };  
+        }
 
         if ('reload' in this.location) {
             this.ctx.nativeMethods.defineProperty(emulation, 'reload', {
-                value: this.ctx.wrap(this.location, 'reload', (target, that) => {
+                value: this.ctx.wrap(
-                    return target.call(that === emulation ? this.location : that);
+                    this.location,
-                }),
+                    'reload',
+                    (target, that) => {
+                        return target.call(
+                            that === emulation ? this.location : that
+                        );
+                    }
+                ),
                 writable: false,
                 enumerable: true,
             });
-        };
+        }
 
         if ('replace' in this.location) {
             this.ctx.nativeMethods.defineProperty(emulation, 'replace', {
-                value: this.ctx.wrap(this.location, 'assign', (target, that, args) => {
+                value: this.ctx.wrap(
-                    if (!args.length || that !== emulation) target.call(that);
+                    this.location,
+                    'assign',
+                    (target, that, args) => {
+                        if (!args.length || that !== emulation)
+                            target.call(that);
                         that = this.location;
-                    let [ input ] = args;
+                        let [input] = args;
 
                         const url = new URL(input, emulation.href);
-                    return target.call(that === emulation ? this.location : that, wrap(url.href));
+                        return target.call(
-                }),
+                            that === emulation ? this.location : that,
+                            wrap(url.href)
+                        );
+                    }
+                ),
                 writable: false,
                 enumerable: true,
             });
-        };
+        }
 
         if ('assign' in this.location) {
             this.ctx.nativeMethods.defineProperty(emulation, 'assign', {
-                value: this.ctx.wrap(this.location, 'assign', (target, that, args) => {
+                value: this.ctx.wrap(
-                    if (!args.length || that !== emulation) target.call(that);
+                    this.location,
+                    'assign',
+                    (target, that, args) => {
+                        if (!args.length || that !== emulation)
+                            target.call(that);
                         that = this.location;
-                    let [ input ] = args;
+                        let [input] = args;
 
                         const url = new URL(input, emulation.href);
-                    return target.call(that === emulation ? this.location : that, wrap(url.href));
+                        return target.call(
-                }),
+                            that === emulation ? this.location : that,
+                            wrap(url.href)
+                        );
+                    }
+                ),
                 writable: false,
                 enumerable: true,
             });
-        };
+        }
 
         if ('ancestorOrigins' in this.location) {
-            this.ctx.nativeMethods.defineProperty(emulation, 'ancestorOrigins', {
+            this.ctx.nativeMethods.defineProperty(
+                emulation,
+                'ancestorOrigins',
+                {
                     get() {
                         const arr = [];
-                    if (that.window.DOMStringList) that.ctx.nativeMethods.setPrototypeOf(arr, that.window.DOMStringList.prototype);
+                        if (that.window.DOMStringList)
+                            that.ctx.nativeMethods.setPrototypeOf(
+                                arr,
+                                that.window.DOMStringList.prototype
+                            );
                         return arr;
                     },
                     set: undefined,
                     enumerable: true,
-            });
+                }
-        };
+            );
-        
+        }
 
         this.ctx.nativeMethods.defineProperty(emulation, 'toString', {
             value: this.ctx.wrap(this.location, 'toString', () => {
@@ -126,10 +185,14 @@ class LocationApi extends EventEmitter {
             enumerable: false,
         });
 
-        if (this.ctx.window.Location) this.ctx.nativeMethods.setPrototypeOf(emulation, this.ctx.window.Location.prototype);
+        if (this.ctx.window.Location)
+            this.ctx.nativeMethods.setPrototypeOf(
+                emulation,
+                this.ctx.window.Location.prototype
+            );
 
         return emulation;
-    };
+    }
-};
+}
 
 export default LocationApi;

src/client/message.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class MessageApi extends EventEmitter {
     constructor(ctx) {
@@ -12,9 +12,15 @@ class MessageApi extends EventEmitter {
         this.mpProto = this.MessagePort.prototype || {};
         this.mpPostMessage = this.mpProto.postMessage;
         this.messageProto = this.MessageEvent.prototype || {};
-        this.messageData = ctx.nativeMethods.getOwnPropertyDescriptor(this.messageProto, 'data');
+        this.messageData = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.messageOrigin = ctx.nativeMethods.getOwnPropertyDescriptor(this.messageProto, 'origin');
+            this.messageProto,
-    };
+            'data'
+        );
+        this.messageOrigin = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.messageProto,
+            'origin'
+        );
+    }
     overridePostMessage() {
         this.ctx.override(this.window, 'postMessage', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
@@ -24,61 +30,100 @@ class MessageApi extends EventEmitter {
             let transfer;
 
             if (!this.ctx.worker) {
-                [ message, origin, transfer = [] ] = args;
+                [message, origin, transfer = []] = args;
             } else {
-                [ message, transfer = [] ] = args;
+                [message, transfer = []] = args;
-            };
+            }
 
-            const event = new HookEvent({ message, origin, transfer, worker: this.ctx.worker }, target, that);
+            const event = new HookEvent(
+                { message, origin, transfer, worker: this.ctx.worker },
+                target,
+                that
+            );
             this.emit('postMessage', event);
 
             if (event.intercepted) return event.returnValue;
-            return this.ctx.worker ? event.target.call(event.that, event.data.message, event.data.transfer) : event.target.call(event.that, event.data.message, event.data.origin, event.data.transfer);
+            return this.ctx.worker
+                ? event.target.call(
+                      event.that,
+                      event.data.message,
+                      event.data.transfer
+                  )
+                : event.target.call(
+                      event.that,
+                      event.data.message,
+                      event.data.origin,
+                      event.data.transfer
+                  );
         });
-    };
+    }
     wrapPostMessage(obj, prop, noOrigin = false) {
         return this.ctx.wrap(obj, prop, (target, that, args) => {
-            if (this.ctx.worker ? !args.length : 2 > args) return target.apply(that, args);
+            if (this.ctx.worker ? !args.length : 2 > args)
+                return target.apply(that, args);
             let message;
             let origin;
             let transfer;
 
             if (!noOrigin) {
-                [ message, origin, transfer = [] ] = args;
+                [message, origin, transfer = []] = args;
             } else {
-                [ message, transfer = [] ] = args;
+                [message, transfer = []] = args;
                 origin = null;
-            };
+            }
 
-            const event = new HookEvent({ message, origin, transfer, worker: this.ctx.worker }, target, obj);
+            const event = new HookEvent(
+                { message, origin, transfer, worker: this.ctx.worker },
+                target,
+                obj
+            );
             this.emit('postMessage', event);
 
             if (event.intercepted) return event.returnValue;
-            return noOrigin ? event.target.call(event.that, event.data.message, event.data.transfer) : event.target.call(event.that, event.data.message, event.data.origin, event.data.transfer);
+            return noOrigin
+                ? event.target.call(
+                      event.that,
+                      event.data.message,
+                      event.data.transfer
+                  )
+                : event.target.call(
+                      event.that,
+                      event.data.message,
+                      event.data.origin,
+                      event.data.transfer
+                  );
         });
-    };
+    }
     overrideMessageOrigin() {
         this.ctx.overrideDescriptor(this.messageProto, 'origin', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('origin', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
-            }
+            },
         });
-    };
+    }
     overrideMessageData() {
         this.ctx.overrideDescriptor(this.messageProto, 'data', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('data', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
-            }
+            },
         });
-    };
+    }
-};
+}
 
 export default MessageApi;

src/client/native/function.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class FunctionHook extends EventEmitter {
     constructor(ctx) {
@@ -13,9 +13,12 @@ class FunctionHook extends EventEmitter {
         this.call = this.fnProto.call;
         this.apply = this.fnProto.apply;
         this.bind = this.fnProto.bind;
-    };
+    }
     overrideFunction() {
-        this.ctx.override(this.window, 'Function', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'Function',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
 
                 let script = args[args.length - 1];
@@ -23,15 +26,25 @@ class FunctionHook extends EventEmitter {
 
                 for (let i = 0; i < args.length - 1; i++) {
                     fnArgs.push(args[i]);
-            };
+                }
 
-            const event = new HookEvent({ script, args: fnArgs }, target, that);
+                const event = new HookEvent(
+                    { script, args: fnArgs },
+                    target,
+                    that
+                );
                 this.emit('function', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, ...event.data.args, event.data.script);
+                return event.target.call(
-        }, true);
+                    event.that,
-    };
+                    ...event.data.args,
+                    event.data.script
+                );
+            },
+            true
+        );
+    }
     overrideToString() {
         this.ctx.override(this.fnProto, 'toString', (target, that) => {
             const event = new HookEvent({ fn: that }, target, that);
@@ -40,7 +53,7 @@ class FunctionHook extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.data.fn);
         });
-    };
+    }
-};
+}
 
 export default FunctionHook;

src/client/native/object.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class ObjectHook extends EventEmitter {
     constructor(ctx) {
@@ -10,31 +10,47 @@ class ObjectHook extends EventEmitter {
         this.getOwnPropertyDescriptors = this.Object.getOwnPropertyDescriptors;
         this.getOwnPropertyDescriptor = this.Object.getOwnPropertyDescriptor;
         this.getOwnPropertyNames = this.Object.getOwnPropertyNames;
-    };
+    }
     overrideGetPropertyNames() {
-        this.ctx.override(this.Object, 'getOwnPropertyNames', (target, that, args) => {
+        this.ctx.override(
+            this.Object,
+            'getOwnPropertyNames',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ object ] = args;
+                let [object] = args;
 
-            const event =  new HookEvent({ names: target.call(that, object) }, target, that);
+                const event = new HookEvent(
+                    { names: target.call(that, object) },
+                    target,
+                    that
+                );
                 this.emit('getOwnPropertyNames', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.names;
-        });
+            }
-    };
+        );
+    }
     overrideGetOwnPropertyDescriptors() {
-        this.ctx.override(this.Object, 'getOwnPropertyDescriptors', (target, that, args) => {
+        this.ctx.override(
+            this.Object,
+            'getOwnPropertyDescriptors',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ object ] = args;
+                let [object] = args;
 
-            const event =  new HookEvent({ descriptors: target.call(that, object) }, target, that);
+                const event = new HookEvent(
+                    { descriptors: target.call(that, object) },
+                    target,
+                    that
+                );
                 this.emit('getOwnPropertyDescriptors', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.descriptors;
-        });
+            }
-    };
+        );
-};
+    }
+}
 
 export default ObjectHook;

src/client/navigator.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class NavigatorApi extends EventEmitter {
     constructor(ctx) {
@@ -10,19 +10,23 @@ class NavigatorApi extends EventEmitter {
         this.Navigator = this.window.Navigator || {};
         this.navProto = this.Navigator.prototype || {};
         this.sendBeacon = this.navProto.sendBeacon;
-    };
+    }
     overrideSendBeacon() {
         this.ctx.override(this.navProto, 'sendBeacon', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ url, data = '' ] = args;
+            let [url, data = ''] = args;
 
             const event = new HookEvent({ url, data }, target, that);
             this.emit('sendBeacon', event);
 
             if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.url, event.data.data);
+            return event.target.call(
+                event.that,
+                event.data.url,
+                event.data.data
+            );
         });
-    };
+    }
-};
+}
 
 export default NavigatorApi;

src/client/requests/eventsource.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class EventSourceApi extends EventEmitter {
     constructor(ctx) {
@@ -8,38 +8,50 @@ class EventSourceApi extends EventEmitter {
         this.window = ctx.window;
         this.EventSource = this.window.EventSource || {};
         this.esProto = this.EventSource.prototype || {};
-        this.url = ctx.nativeMethods.getOwnPropertyDescriptor(this.esProto, 'url');
+        this.url = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.esProto,
+            'url'
+        );
         this.CONNECTING = 0;
         this.OPEN = 1;
         this.CLOSED = 2;
-    };
+    }
     overrideConstruct() {
-        this.ctx.override(this.window, 'EventSource', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'EventSource',
+            (target, that, args) => {
                 if (!args.length) return new target(...args);
-            let [ url, config = {} ] = args;
+                let [url, config = {}] = args;
 
                 const event = new HookEvent({ url, config }, target, that);
                 this.emit('construct', event);
 
                 if (event.intercepted) return event.returnValue;
                 return new event.target(event.data.url, event.data.config);
-        }, true);
+            },
+            true
+        );
 
         if ('EventSource' in this.window) {
             this.window.EventSource.CONNECTING = this.CONNECTING;
             this.window.EventSource.OPEN = this.OPEN;
             this.window.EventSource.CLOSED = this.CLOSED;
-        };
+        }
-    };
+    }
     overrideUrl() {
         this.ctx.overrideDescriptor(this.esProto, 'url', {
             get: (target, that) => {
-               const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('url', event);
                 return event.data.value;
             },
         });
-    };
+    }
-};
+}
 
 export default EventSourceApi;

src/client/requests/fetch.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class Fetch extends EventEmitter {
     constructor(ctx) {
@@ -13,49 +13,75 @@ class Fetch extends EventEmitter {
         this.reqProto = this.Request ? this.Request.prototype : {};
         this.resProto = this.Response ? this.Response.prototype : {};
         this.headersProto = this.Headers ? this.Headers.prototype : {};
-        this.reqUrl = ctx.nativeMethods.getOwnPropertyDescriptor(this.reqProto, 'url');
+        this.reqUrl = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.resUrl = ctx.nativeMethods.getOwnPropertyDescriptor(this.resProto, 'url');
+            this.reqProto,
-        this.reqHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(this.reqProto, 'headers');
+            'url'
-        this.resHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(this.resProto, 'headers');
+        );
-    };
+        this.resUrl = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.resProto,
+            'url'
+        );
+        this.reqHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.reqProto,
+            'headers'
+        );
+        this.resHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.resProto,
+            'headers'
+        );
+    }
     override() {
         this.overrideRequest();
         this.overrideUrl();
         this.overrideHeaders();
         return true;
-    };
+    }
     overrideRequest() {
         if (!this.fetch) return false;
 
         this.ctx.override(this.window, 'fetch', (target, that, args) => {
-            if (!args.length || args[0] instanceof this.Request) return target.apply(that, args);
+            if (!args.length || args[0] instanceof this.Request)
+                return target.apply(that, args);
 
-            let [ input, options = {} ] = args;
+            let [input, options = {}] = args;
             const event = new HookEvent({ input, options }, target, that);
 
             this.emit('request', event);
             if (event.intercepted) return event.returnValue;
 
-            return event.target.call(event.that, event.data.input, event.data.options);
+            return event.target.call(
+                event.that,
+                event.data.input,
+                event.data.options
+            );
         });
 
-        this.ctx.override(this.window, 'Request', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'Request',
+            (target, that, args) => {
                 if (!args.length) return new target(...args);
 
-            let [ input, options = {} ] = args;
+                let [input, options = {}] = args;
                 const event = new HookEvent({ input, options }, target);
 
                 this.emit('request', event);
                 if (event.intercepted) return event.returnValue;
 
                 return new event.target(event.data.input, event.data.options);
-        }, true);
+            },
+            true
+        );
         return true;
-    };
+    }
     overrideUrl() {
         this.ctx.overrideDescriptor(this.reqProto, 'url', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
 
                 this.emit('requestUrl', event);
                 if (event.intercepted) return event.returnValue;
@@ -66,7 +92,11 @@ class Fetch extends EventEmitter {
 
         this.ctx.overrideDescriptor(this.resProto, 'url', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
 
                 this.emit('responseUrl', event);
                 if (event.intercepted) return event.returnValue;
@@ -75,13 +105,17 @@ class Fetch extends EventEmitter {
             },
         });
         return true;
-    };
+    }
     overrideHeaders() {
         if (!this.Headers) return false;
 
         this.ctx.overrideDescriptor(this.reqProto, 'headers', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
 
                 this.emit('requestHeaders', event);
                 if (event.intercepted) return event.returnValue;
@@ -92,7 +126,11 @@ class Fetch extends EventEmitter {
 
         this.ctx.overrideDescriptor(this.resProto, 'headers', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
 
                 this.emit('responseHeaders', event);
                 if (event.intercepted) return event.returnValue;
@@ -101,9 +139,13 @@ class Fetch extends EventEmitter {
             },
         });
 
-        this.ctx.override(this.headersProto, 'get', (target, that, [ name ]) => {
+        this.ctx.override(this.headersProto, 'get', (target, that, [name]) => {
             if (!name) return target.call(that);
-            const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
+            const event = new HookEvent(
+                { name, value: target.call(that, name) },
+                target,
+                that
+            );
 
             this.emit('getHeader', event);
             if (event.intercepted) return event.returnValue;
@@ -114,20 +156,28 @@ class Fetch extends EventEmitter {
         this.ctx.override(this.headersProto, 'set', (target, that, args) => {
             if (2 > args.length) return target.apply(that, args);
 
-            let [ name, value ] = args;
+            let [name, value] = args;
             const event = new HookEvent({ name, value }, target, that);
 
             this.emit('setHeader', event);
             if (event.intercepted) return event.returnValue;
 
-            return event.target.call(event.that, event.data.name, event.data.value);
+            return event.target.call(
+                event.that,
+                event.data.name,
+                event.data.value
+            );
         });
 
         this.ctx.override(this.headersProto, 'has', (target, that, args) => {
             if (!args.length) return target.call(that);
-            let [ name ] = args;
+            let [name] = args;
 
-            const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
+            const event = new HookEvent(
+                { name, value: target.call(that, name) },
+                target,
+                that
+            );
 
             this.emit('hasHeader', event);
             if (event.intercepted) return event.returnValue;
@@ -138,19 +188,23 @@ class Fetch extends EventEmitter {
         this.ctx.override(this.headersProto, 'append', (target, that, args) => {
             if (2 > args.length) return target.apply(that, args);
 
-            let [ name, value ] = args;
+            let [name, value] = args;
             const event = new HookEvent({ name, value }, target, that);
 
             this.emit('appendHeader', event);
             if (event.intercepted) return event.returnValue;
 
-            return event.target.call(event.that, event.data.name, event.data.value);
+            return event.target.call(
+                event.that,
+                event.data.name,
+                event.data.value
+            );
         });
 
         this.ctx.override(this.headersProto, 'delete', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
 
-            let [ name ] = args;
+            let [name] = args;
             const event = new HookEvent({ name }, target, that);
 
             this.emit('deleteHeader', event);
@@ -160,7 +214,7 @@ class Fetch extends EventEmitter {
         });
 
         return true;
-    };
+    }
-};
+}
 
 export default Fetch;

src/client/requests/websocket.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class WebSocketApi extends EventEmitter {
     constructor(ctx) {
@@ -8,51 +8,71 @@ class WebSocketApi extends EventEmitter {
         this.window = ctx.window;
         this.WebSocket = this.window.WebSocket || {};
         this.wsProto = this.WebSocket.prototype || {};
-        this.url = ctx.nativeMethods.getOwnPropertyDescriptor(this.wsProto, 'url');
+        this.url = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.protocol = ctx.nativeMethods.getOwnPropertyDescriptor(this.wsProto, 'protocol');
+            this.wsProto,
+            'url'
+        );
+        this.protocol = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.wsProto,
+            'protocol'
+        );
         this.send = this.wsProto.send;
         this.close = this.wsProto.close;
         this.CONNECTING = 0;
         this.OPEN = 1;
         this.CLOSING = 2;
         this.CLOSED = 3;
-    };
+    }
     overrideWebSocket() {
-        this.ctx.override(this.window, 'WebSocket', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'WebSocket',
+            (target, that, args) => {
                 if (!args.length) return new target(...args);
-            let [ url, protocols = [] ] = args;
+                let [url, protocols = []] = args;
 
-            if (!this.ctx.nativeMethods.isArray(protocols)) protocols = [ protocols ];
+                if (!this.ctx.nativeMethods.isArray(protocols))
+                    protocols = [protocols];
                 const event = new HookEvent({ url, protocols }, target, that);
                 this.emit('websocket', event);
 
                 if (event.intercepted) return event.returnValue;
                 return new event.target(event.data.url, event.data.protocols);
-        }, true);
+            },
+            true
+        );
 
         this.window.WebSocket.CONNECTING = this.CONNECTING;
         this.window.WebSocket.OPEN = this.OPEN;
         this.window.WebSocket.CLOSING = this.CLOSING;
         this.window.WebSocket.CLOSED = this.CLOSED;
-    };
+    }
     overrideUrl() {
         this.ctx.overrideDescriptor(this.wsProto, 'url', {
             get: (target, that) => {
-               const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('url', event);
                 return event.data.value;
             },
         });
-    };
+    }
     overrideProtocol() {
         this.ctx.overrideDescriptor(this.wsProto, 'protocol', {
             get: (target, that) => {
-               const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('protocol', event);
                 return event.data.value;
             },
         });
-    };
+    }
-};
+}
 
 export default WebSocketApi;

src/client/requests/xhr.js

@@ -1,5 +1,5 @@
-import EventEmitter from "../events.js";
+import EventEmitter from '../events.js';
-import HookEvent from "../hook.js";
+import HookEvent from '../hook.js';
 
 class Xhr extends EventEmitter {
     constructor(ctx) {
@@ -7,17 +7,25 @@ class Xhr extends EventEmitter {
         this.ctx = ctx;
         this.window = ctx.window;
         this.XMLHttpRequest = this.window.XMLHttpRequest;
-        this.xhrProto = this.window.XMLHttpRequest ? this.window.XMLHttpRequest.prototype : {};
+        this.xhrProto = this.window.XMLHttpRequest
+            ? this.window.XMLHttpRequest.prototype
+            : {};
         this.open = this.xhrProto.open;
         this.abort = this.xhrProto.abort;
         this.send = this.xhrProto.send;
-        this.overrideMimeType = this.xhrProto.overrideMimeType
+        this.overrideMimeType = this.xhrProto.overrideMimeType;
         this.getAllResponseHeaders = this.xhrProto.getAllResponseHeaders;
         this.getResponseHeader = this.xhrProto.getResponseHeader;
         this.setRequestHeader = this.xhrProto.setRequestHeader;
-        this.responseURL = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseURL');
+        this.responseURL = ctx.nativeMethods.getOwnPropertyDescriptor(
-        this.responseText = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseText');
+            this.xhrProto,
-    };
+            'responseURL'
+        );
+        this.responseText = ctx.nativeMethods.getOwnPropertyDescriptor(
+            this.xhrProto,
+            'responseText'
+        );
+    }
     override() {
         this.overrideOpen();
         this.overrideSend();
@@ -25,13 +33,18 @@ class Xhr extends EventEmitter {
         this.overrideGetResHeader();
         this.overrideGetResHeaders();
         this.overrideSetReqHeader();
-    };
+    }
     overrideOpen() {
         this.ctx.override(this.xhrProto, 'open', (target, that, args) => {
             if (2 > args.length) return target.apply(that, args);
 
-            let [ method, input, async = true, user = null, password = null ] = args;
+            let [method, input, async = true, user = null, password = null] =
-            const event = new HookEvent({ method, input, async, user, password }, target, that);
+                args;
+            const event = new HookEvent(
+                { method, input, async, user, password },
+                target,
+                that
+            );
 
             this.emit('open', event);
             if (event.intercepted) return event.returnValue;
@@ -45,65 +58,94 @@ class Xhr extends EventEmitter {
                 event.data.password
             );
         });
-    };
+    }
     overrideResponseUrl() {
         this.ctx.overrideDescriptor(this.xhrProto, 'responseURL', {
             get: (target, that) => {
-                const event = new HookEvent({ value: target.call(that) }, target, that);
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
                 this.emit('responseUrl', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.value;
             },
         });
-    };
+    }
     overrideSend() {
-        this.ctx.override(this.xhrProto, 'send', (target, that, [ body = null ]) => {
+        this.ctx.override(
+            this.xhrProto,
+            'send',
+            (target, that, [body = null]) => {
                 const event = new HookEvent({ body }, target, that);
 
                 this.emit('send', event);
                 if (event.intercepted) return event.returnValue;
 
-            return event.target.call(
+                return event.target.call(event.that, event.data.body);
-                event.that,
+            }
-                event.data.body,
         );
-        });
+    }
-    };
     overrideSetReqHeader() {
-        this.ctx.override(this.xhrProto, 'setRequestHeader', (target, that, args) => {
+        this.ctx.override(
+            this.xhrProto,
+            'setRequestHeader',
+            (target, that, args) => {
                 if (2 > args.length) return target.apply(that, args);
 
-            let [ name, value ] = args;
+                let [name, value] = args;
                 const event = new HookEvent({ name, value }, target, that);
 
                 this.emit('setReqHeader', event);
                 if (event.intercepted) return event.returnValue;
 
-            return event.target.call(event.that, event.data.name, event.data.value);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.name,
+                    event.data.value
+                );
+            }
+        );
+    }
     overrideGetResHeaders() {
-        this.ctx.override(this.xhrProto, 'getAllResponseHeaders', (target, that) => {
+        this.ctx.override(
-            const event = new HookEvent({ value: target.call(that) }, target, that);
+            this.xhrProto,
+            'getAllResponseHeaders',
+            (target, that) => {
+                const event = new HookEvent(
+                    { value: target.call(that) },
+                    target,
+                    that
+                );
 
                 this.emit('getAllResponseHeaders', event);
                 if (event.intercepted) return event.returnValue;
 
                 return event.data.value;
-        });
+            }
-    };
+        );
+    }
     overrideGetResHeader() {
-        this.ctx.override(this.xhrProto, 'getResponseHeader', (target, that, args) => {
+        this.ctx.override(
+            this.xhrProto,
+            'getResponseHeader',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ name ] = args;
+                let [name] = args;
 
-            const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
+                const event = new HookEvent(
+                    { name, value: target.call(that, name) },
+                    target,
+                    that
+                );
                 if (event.intercepted) return event.returnValue;
 
                 return event.data.value;
-        });
+            }
-    };
+        );
-}; 
+    }
+}
 
-export default Xhr
+export default Xhr;

src/client/storage.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class StorageApi extends EventEmitter {
     constructor(ctx) {
@@ -17,73 +17,110 @@ class StorageApi extends EventEmitter {
         this.key = this.storeProto.key || null;
         this.methods = ['key', 'getItem', 'setItem', 'removeItem', 'clear'];
         this.wrappers = new ctx.nativeMethods.Map();
-    };
+    }
     overrideMethods() {
         this.ctx.override(this.storeProto, 'getItem', (target, that, args) => {
-            if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
+            if (!args.length)
-            let [ name ] = args;
+                return target.apply(this.wrappers.get(that) || that, args);
+            let [name] = args;
 
-            const event = new HookEvent({ name }, target, (this.wrappers.get(that) || that));
+            const event = new HookEvent(
+                { name },
+                target,
+                this.wrappers.get(that) || that
+            );
             this.emit('getItem', event);
 
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that, event.data.name);
         });
         this.ctx.override(this.storeProto, 'setItem', (target, that, args) => {
-            if (2 > args.length) return target.apply((this.wrappers.get(that) || that), args);
+            if (2 > args.length)
-            let [ name, value ] = args;
+                return target.apply(this.wrappers.get(that) || that, args);
+            let [name, value] = args;
 
-            const event = new HookEvent({ name, value }, target, (this.wrappers.get(that) || that));
+            const event = new HookEvent(
+                { name, value },
+                target,
+                this.wrappers.get(that) || that
+            );
             this.emit('setItem', event);
 
             if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.name, event.data.value);
+            return event.target.call(
+                event.that,
+                event.data.name,
+                event.data.value
+            );
         });
-        this.ctx.override(this.storeProto, 'removeItem', (target, that, args) => {
+        this.ctx.override(
-            if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
+            this.storeProto,
-            let [ name ] = args;
+            'removeItem',
+            (target, that, args) => {
+                if (!args.length)
+                    return target.apply(this.wrappers.get(that) || that, args);
+                let [name] = args;
 
-            const event = new HookEvent({ name }, target, (this.wrappers.get(that) || that));
+                const event = new HookEvent(
+                    { name },
+                    target,
+                    this.wrappers.get(that) || that
+                );
                 this.emit('removeItem', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.call(event.that, event.data.name);
-        });
+            }
+        );
         this.ctx.override(this.storeProto, 'clear', (target, that) => {
-            const event = new HookEvent(null, target, (this.wrappers.get(that) || that));
+            const event = new HookEvent(
+                null,
+                target,
+                this.wrappers.get(that) || that
+            );
             this.emit('clear', event);
 
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that);
         });
         this.ctx.override(this.storeProto, 'key', (target, that, args) => {
-            if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
+            if (!args.length)
-            let [ index ] = args;
+                return target.apply(this.wrappers.get(that) || that, args);
+            let [index] = args;
 
-            const event = new HookEvent({ index }, target, (this.wrappers.get(that) || that));
+            const event = new HookEvent(
+                { index },
+                target,
+                this.wrappers.get(that) || that
+            );
             this.emit('key', event);
 
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that, event.data.index);
         });
-    };
+    }
     overrideLength() {
         this.ctx.overrideDescriptor(this.storeProto, 'length', {
             get: (target, that) => {
-                const event = new HookEvent({ length: target.call((this.wrappers.get(that) || that)) }, target, (this.wrappers.get(that) || that));
+                const event = new HookEvent(
+                    { length: target.call(this.wrappers.get(that) || that) },
+                    target,
+                    this.wrappers.get(that) || that
+                );
                 this.emit('length', event);
 
                 if (event.intercepted) return event.returnValue;
                 return event.data.length;
             },
         });
-    };
+    }
     emulate(storage, obj = {}) {
         this.ctx.nativeMethods.setPrototypeOf(obj, this.storeProto);
 
         const proxy = new this.ctx.window.Proxy(obj, {
             get: (target, prop) => {
-                if (prop in this.storeProto || typeof prop === 'symbol') return storage[prop];
+                if (prop in this.storeProto || typeof prop === 'symbol')
+                    return storage[prop];
 
                 const event = new HookEvent({ name: prop }, null, storage);
                 this.emit('get', event);
@@ -92,14 +129,19 @@ class StorageApi extends EventEmitter {
                 return storage[event.data.name];
             },
             set: (target, prop, value) => {
-                if (prop in this.storeProto || typeof prop === 'symbol') return storage[prop] = value;
+                if (prop in this.storeProto || typeof prop === 'symbol')
+                    return (storage[prop] = value);
 
-                const event = new HookEvent({ name: prop, value }, null, storage);
+                const event = new HookEvent(
+                    { name: prop, value },
+                    null,
+                    storage
+                );
                 this.emit('set', event);
 
                 if (event.intercepted) return event.returnValue;
 
-                return storage[event.data.name] = event.data.value;
+                return (storage[event.data.name] = event.data.value);
             },
             deleteProperty: (target, prop) => {
                 if (typeof prop === 'symbol') return delete storage[prop];
@@ -117,8 +159,7 @@ class StorageApi extends EventEmitter {
         this.ctx.nativeMethods.setPrototypeOf(proxy, this.storeProto);
 
         return proxy;
-    };  
+    }
-    
+}
-};
 
 export default StorageApi;

src/client/url.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class URLApi extends EventEmitter {
     constructor(ctx) {
@@ -9,11 +9,11 @@ class URLApi extends EventEmitter {
         this.URL = this.window.URL || {};
         this.createObjectURL = this.URL.createObjectURL;
         this.revokeObjectURL = this.URL.revokeObjectURL;
-    };
+    }
     overrideObjectURL() {
         this.ctx.override(this.URL, 'createObjectURL', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ object ] = args;
+            let [object] = args;
 
             const event = new HookEvent({ object }, target, that);
             this.emit('createObjectURL', event);
@@ -23,7 +23,7 @@ class URLApi extends EventEmitter {
         });
         this.ctx.override(this.URL, 'revokeObjectURL', (target, that, args) => {
             if (!args.length) return target.apply(that, args);
-            let [ url ] = args;
+            let [url] = args;
 
             const event = new HookEvent({ url }, target, that);
             this.emit('revokeObjectURL', event);
@@ -31,7 +31,7 @@ class URLApi extends EventEmitter {
             if (event.intercepted) return event.returnValue;
             return event.target.call(event.that, event.data.url);
         });
-    };
+    }
-};  
+}
 
 export default URLApi;

src/client/worker.js

@@ -1,5 +1,5 @@
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import HookEvent from "./hook.js";
+import HookEvent from './hook.js';
 
 class Workers extends EventEmitter {
     constructor(ctx) {
@@ -13,45 +13,75 @@ class Workers extends EventEmitter {
         this.postMessage = this.workerProto.postMessage;
         this.terminate = this.workerProto.terminate;
         this.addModule = this.workletProto.addModule;
-    };
+    }
     overrideWorker() {
-        this.ctx.override(this.window, 'Worker', (target, that, args) => {
+        this.ctx.override(
+            this.window,
+            'Worker',
+            (target, that, args) => {
                 if (!args.length) return new target(...args);
-            let [ url, options = {} ] = args;
+                let [url, options = {}] = args;
 
                 const event = new HookEvent({ url, options }, target, that);
                 this.emit('worker', event);
 
                 if (event.intercepted) return event.returnValue;
-            return new event.target(...[ event.data.url, event.data.options ]);
+                return new event.target(
-        }, true);
+                    ...[event.data.url, event.data.options]
-    };
+                );
+            },
+            true
+        );
+    }
     overrideAddModule() {
-        this.ctx.override(this.workletProto, 'addModule', (target, that, args) => {
+        this.ctx.override(
+            this.workletProto,
+            'addModule',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ url, options = {} ] = args;
+                let [url, options = {}] = args;
 
                 const event = new HookEvent({ url, options }, target, that);
                 this.emit('addModule', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.url, event.data.options);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.url,
+                    event.data.options
+                );
+            }
+        );
+    }
     overridePostMessage() {
-        this.ctx.override(this.workerProto, 'postMessage', (target, that, args) => {
+        this.ctx.override(
+            this.workerProto,
+            'postMessage',
+            (target, that, args) => {
                 if (!args.length) return target.apply(that, args);
-            let [ message, transfer = [] ] = args;
+                let [message, transfer = []] = args;
 
-            const event = new HookEvent({ message, transfer }, target, that);
+                const event = new HookEvent(
+                    { message, transfer },
+                    target,
+                    that
+                );
                 this.emit('postMessage', event);
 
                 if (event.intercepted) return event.returnValue;
-            return event.target.call(event.that, event.data.message, event.data.transfer);
+                return event.target.call(
-        });
+                    event.that,
-    };
+                    event.data.message,
+                    event.data.transfer
+                );
+            }
+        );
+    }
     overrideImportScripts() {
-        this.ctx.override(this.window, 'importScripts', (target, that, scripts) => {
+        this.ctx.override(
+            this.window,
+            'importScripts',
+            (target, that, scripts) => {
                 if (!scripts.length) return target.apply(that, scripts);
 
                 const event = new HookEvent({ scripts }, target, that);
@@ -59,8 +89,9 @@ class Workers extends EventEmitter {
 
                 if (event.intercepted) return event.returnValue;
                 return event.target.apply(event.that, event.data.scripts);
-        });
+            }
-    };
+        );
-};
+    }
+}
 
 export default Workers;

src/rewrite/codecs.js

@@ -3,15 +3,30 @@
 // Do not use any browser or node-specific API!
 // -------------------------------------------------------------
 export const xor = {
-    encode(str){
+    encode(str) {
         if (!str) return str;
-        return encodeURIComponent(str.toString().split('').map((char, ind) => ind % 2 ? String.fromCharCode(char.charCodeAt() ^ 2) : char).join(''));
+        return encodeURIComponent(
+            str
+                .toString()
+                .split('')
+                .map((char, ind) =>
+                    ind % 2 ? String.fromCharCode(char.charCodeAt() ^ 2) : char
+                )
+                .join('')
+        );
     },
-    decode(str){
+    decode(str) {
         if (!str) return str;
-        let [ input, ...search ] = str.split('?');
+        let [input, ...search] = str.split('?');
 
-        return decodeURIComponent(input).split('').map((char, ind) => ind % 2 ? String.fromCharCode(char.charCodeAt(0) ^ 2) : char).join('') + (search.length ? '?' + search.join('?') : '');
+        return (
+            decodeURIComponent(input)
+                .split('')
+                .map((char, ind) =>
+                    ind % 2 ? String.fromCharCode(char.charCodeAt(0) ^ 2) : char
+                )
+                .join('') + (search.length ? '?' + search.join('?') : '')
+        );
     },
 };
 
@@ -27,10 +42,12 @@ export const plain = {
 };
 
 export const base64 = {
-    encode(str){
+    encode(str) {
         if (!str) return str;
         str = str.toString();
-        const b64chs = Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=');
+        const b64chs = Array.from(
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+        );
         let u32;
         let c0;
         let c1;
@@ -38,21 +55,95 @@ export const base64 = {
         let asc = '';
         let pad = str.length % 3;
 
-        for (let i = 0; i < str.length;) {
+        for (let i = 0; i < str.length; ) {
-            if((c0 = str.charCodeAt(i++)) > 255 || (c1 = str.charCodeAt(i++)) > 255 || (c2 = str.charCodeAt(i++)) > 255)throw new TypeError('invalid character found');
+            if (
+                (c0 = str.charCodeAt(i++)) > 255 ||
+                (c1 = str.charCodeAt(i++)) > 255 ||
+                (c2 = str.charCodeAt(i++)) > 255
+            )
+                throw new TypeError('invalid character found');
             u32 = (c0 << 16) | (c1 << 8) | c2;
-            asc += b64chs[u32 >> 18 & 63]
+            asc +=
-                + b64chs[u32 >> 12 & 63]
+                b64chs[(u32 >> 18) & 63] +
-                + b64chs[u32 >> 6 & 63]
+                b64chs[(u32 >> 12) & 63] +
-                + b64chs[u32 & 63];
+                b64chs[(u32 >> 6) & 63] +
+                b64chs[u32 & 63];
         }
 
-        return encodeURIComponent(pad ? asc.slice(0, pad - 3) + '==='.substr(pad) : asc);
+        return encodeURIComponent(
+            pad ? asc.slice(0, pad - 3) + '==='.substr(pad) : asc
+        );
     },
-    decode(str){
+    decode(str) {
         if (!str) return str;
         str = decodeURIComponent(str.toString());
-        const b64tab = {"0":52,"1":53,"2":54,"3":55,"4":56,"5":57,"6":58,"7":59,"8":60,"9":61,"A":0,"B":1,"C":2,"D":3,"E":4,"F":5,"G":6,"H":7,"I":8,"J":9,"K":10,"L":11,"M":12,"N":13,"O":14,"P":15,"Q":16,"R":17,"S":18,"T":19,"U":20,"V":21,"W":22,"X":23,"Y":24,"Z":25,"a":26,"b":27,"c":28,"d":29,"e":30,"f":31,"g":32,"h":33,"i":34,"j":35,"k":36,"l":37,"m":38,"n":39,"o":40,"p":41,"q":42,"r":43,"s":44,"t":45,"u":46,"v":47,"w":48,"x":49,"y":50,"z":51,"+":62,"/":63,"=":64};
+        const b64tab = {
+            0: 52,
+            1: 53,
+            2: 54,
+            3: 55,
+            4: 56,
+            5: 57,
+            6: 58,
+            7: 59,
+            8: 60,
+            9: 61,
+            A: 0,
+            B: 1,
+            C: 2,
+            D: 3,
+            E: 4,
+            F: 5,
+            G: 6,
+            H: 7,
+            I: 8,
+            J: 9,
+            K: 10,
+            L: 11,
+            M: 12,
+            N: 13,
+            O: 14,
+            P: 15,
+            Q: 16,
+            R: 17,
+            S: 18,
+            T: 19,
+            U: 20,
+            V: 21,
+            W: 22,
+            X: 23,
+            Y: 24,
+            Z: 25,
+            a: 26,
+            b: 27,
+            c: 28,
+            d: 29,
+            e: 30,
+            f: 31,
+            g: 32,
+            h: 33,
+            i: 34,
+            j: 35,
+            k: 36,
+            l: 37,
+            m: 38,
+            n: 39,
+            o: 40,
+            p: 41,
+            q: 42,
+            r: 43,
+            s: 44,
+            t: 45,
+            u: 46,
+            v: 47,
+            w: 48,
+            x: 49,
+            y: 50,
+            z: 51,
+            '+': 62,
+            '/': 63,
+            '=': 64,
+        };
         str = str.replace(/\s+/g, '');
         str += '=='.slice(2 - (str.length & 3));
         let u24;
@@ -60,15 +151,23 @@ export const base64 = {
         let r1;
         let r2;
 
-        for (let i = 0; i < str.length;) {
+        for (let i = 0; i < str.length; ) {
-            u24 = b64tab[str.charAt(i++)] << 18
+            u24 =
-            | b64tab[str.charAt(i++)] << 12
+                (b64tab[str.charAt(i++)] << 18) |
-            | (r1 = b64tab[str.charAt(i++)]) << 6
+                (b64tab[str.charAt(i++)] << 12) |
-            | (r2 = b64tab[str.charAt(i++)]);
+                ((r1 = b64tab[str.charAt(i++)]) << 6) |
-            bin += r1 === 64 ? String.fromCharCode(u24 >> 16 & 255)
+                (r2 = b64tab[str.charAt(i++)]);
-                : r2 === 64 ? String.fromCharCode(u24 >> 16 & 255, u24 >> 8 & 255)
+            bin +=
-                    : String.fromCharCode(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
+                r1 === 64
-        };
+                    ? String.fromCharCode((u24 >> 16) & 255)
+                    : r2 === 64
+                    ? String.fromCharCode((u24 >> 16) & 255, (u24 >> 8) & 255)
+                    : String.fromCharCode(
+                          (u24 >> 16) & 255,
+                          (u24 >> 8) & 255,
+                          u24 & 255
+                      );
+        }
         return bin;
     },
 };

src/rewrite/cookie.js

@@ -8,17 +8,16 @@ function validateCookie(cookie, meta, js = false) {
     if (cookie.httpOnly && !!js) return false;
 
     if (cookie.domain.startsWith('.')) {
-
         if (!meta.url.hostname.endsWith(cookie.domain.slice(1))) return false;
         return true;
-    };
+    }
 
     if (cookie.domain !== meta.url.hostname) return false;
     if (cookie.secure && meta.url.protocol === 'http:') return false;
     if (!meta.url.pathname.startsWith(cookie.path)) return false;
 
     return true;
-};
+}
 
 async function db(openDB) {
     const db = await openDB('__op', 1, {
@@ -31,8 +30,7 @@ async function db(openDB) {
     });
     db.transaction(['cookies'], 'readwrite').store.index('path');
     return db;
-};
+}
-
 
 function serialize(cookies = [], meta, js) {
     let str = '';
@@ -40,40 +38,39 @@ function serialize(cookies = [], meta, js) {
         if (!validateCookie(cookie, meta, js)) continue;
         if (str.length) str += '; ';
         str += cookie.name;
-        str += '='
+        str += '=';
         str += cookie.value;
-    }; 
+    }
     return str;
-};
+}
 
 async function getCookies(db) {
     const now = new Date();
-    return (await db.getAll('cookies')).filter(cookie => {
+    return (await db.getAll('cookies')).filter((cookie) => {
-        
         let expired = false;
         if (cookie.set) {
             if (cookie.maxAge) {
-                expired = (cookie.set.getTime() + (cookie.maxAge * 1e3)) < now;
+                expired = cookie.set.getTime() + cookie.maxAge * 1e3 < now;
             } else if (cookie.expires) {
                 expired = new Date(cookie.expires.toLocaleString()) < now;
-            };
+            }
-        };
+        }
 
         if (expired) {
             db.delete('cookies', cookie.id);
             return false;
-        };
+        }
 
         return true;
     });
-};
+}
 
 function setCookies(data, db, meta) {
     if (!db) return false;
 
     const cookies = setCookie(data, {
         decodeValues: false,
-    })
+    });
 
     for (const cookie of cookies) {
         if (!cookie.domain) cookie.domain = '.' + meta.url.hostname;
@@ -81,15 +78,15 @@ function setCookies(data, db, meta) {
 
         if (!cookie.domain.startsWith('.')) {
             cookie.domain = '.' + cookie.domain;
-        };
+        }
 
         db.put('cookies', {
             ...cookie,
             id: `${cookie.domain}@${cookie.path}@${cookie.name}`,
             set: new Date(Date.now()),
         });
-    };
+    }
     return true;
-};
+}
 
-export { validateCookie, getCookies, setCookies, db , serialize };
+export { validateCookie, getCookies, setCookies, db, serialize };

src/rewrite/css.js

@@ -1,6 +1,6 @@
-import { parse, walk, generate } from "css-tree";
+import { parse, walk, generate } from 'css-tree';
-import EventEmitter from "./events.js";
+import EventEmitter from './events.js';
-import parsel from "./parsel.js";
+import parsel from './parsel.js';
 
 class CSS extends EventEmitter {
     constructor(ctx) {
@@ -11,26 +11,29 @@ class CSS extends EventEmitter {
         this.parse = parse;
         this.walk = walk;
         this.generate = generate;
-    };
+    }
     rewrite(str, options) {
         return this.recast(str, options, 'rewrite');
-    };
+    }
     source(str, options) {
         return this.recast(str, options, 'source');
-    };
+    }
     recast(str, options, type) {
         if (!str) return str;
         str = new String(str).toString();
         try {
-            const ast = this.parse(str, { ...options, parseCustomProperty: true });
+            const ast = this.parse(str, {
-            this.walk(ast, node => {
+                ...options,
+                parseCustomProperty: true,
+            });
+            this.walk(ast, (node) => {
                 this.emit(node.type, node, options, type);
             });
             return this.generate(ast);
-        } catch(e) {
+        } catch (e) {
             return str;
-        };
+        }
-    };
+    }
-};
+}
 
 export default CSS;

src/rewrite/events.js

@@ -21,20 +21,22 @@
 
 'use strict';
 
-var R = typeof Reflect === 'object' ? Reflect : null
+var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function'
+var ReflectApply =
+    R && typeof R.apply === 'function'
         ? R.apply
         : function ReflectApply(target, receiver, args) {
               return Function.prototype.apply.call(target, receiver, args);
-  }
+          };
 
-var ReflectOwnKeys
+var ReflectOwnKeys;
 if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
+    ReflectOwnKeys = R.ownKeys;
 } else if (Object.getOwnPropertySymbols) {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
+        return Object.getOwnPropertyNames(target).concat(
-      .concat(Object.getOwnPropertySymbols(target));
+            Object.getOwnPropertySymbols(target)
+        );
     };
 } else {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
@@ -46,9 +48,11 @@ function ProcessEmitWarning(warning) {
     if (console && console.warn) console.warn(warning);
 }
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+var NumberIsNaN =
+    Number.isNaN ||
+    function NumberIsNaN(value) {
         return value !== value;
-}
+    };
 
 function EventEmitter() {
     EventEmitter.init.call(this);
@@ -69,27 +73,35 @@ var defaultMaxListeners = 10;
 
 function checkListener(listener) {
     if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+        throw new TypeError(
+            'The "listener" argument must be of type Function. Received type ' +
+                typeof listener
+        );
     }
 }
 
 Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
     enumerable: true,
-  get: function() {
+    get: function () {
         return defaultMaxListeners;
     },
-  set: function(arg) {
+    set: function (arg) {
         if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+            throw new RangeError(
+                'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
+                    arg +
+                    '.'
+            );
         }
         defaultMaxListeners = arg;
-  }
+    },
 });
 
-EventEmitter.init = function() {
+EventEmitter.init = function () {
-
+    if (
-  if (this._events === undefined ||
+        this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
+        this._events === Object.getPrototypeOf(this)._events
+    ) {
         this._events = Object.create(null);
         this._eventsCount = 0;
     }
@@ -101,7 +113,11 @@ EventEmitter.init = function() {
 // that to be increased. Set to zero for unlimited.
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
     if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+        throw new RangeError(
+            'The value of "n" is out of range. It must be a non-negative number. Received ' +
+                n +
+                '.'
+        );
     }
     this._maxListeners = n;
     return this;
@@ -120,42 +136,39 @@ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
 EventEmitter.prototype.emit = function emit(type) {
     var args = [];
     for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+    var doError = type === 'error';
 
     var events = this._events;
-  if (events !== undefined)
+    if (events !== undefined) doError = doError && events.error === undefined;
-    doError = (doError && events.error === undefined);
+    else if (!doError) return false;
-  else if (!doError)
-    return false;
 
     // If there is no 'error' event listener then throw.
     if (doError) {
         var er;
-    if (args.length > 0)
+        if (args.length > 0) er = args[0];
-      er = args[0];
         if (er instanceof Error) {
             // Note: The comments on the `throw` lines are intentional, they show
             // up in Node's output if this results in an unhandled exception.
             throw er; // Unhandled 'error' event
         }
         // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+        var err = new Error(
+            'Unhandled error.' + (er ? ' (' + er.message + ')' : '')
+        );
         err.context = er;
         throw err; // Unhandled 'error' event
     }
 
     var handler = events[type];
 
-  if (handler === undefined)
+    if (handler === undefined) return false;
-    return false;
 
     if (typeof handler === 'function') {
         ReflectApply(handler, this, args);
     } else {
         var len = handler.length;
         var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
+        for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
-      ReflectApply(listeners[i], this, args);
     }
 
     return true;
@@ -176,8 +189,11 @@ function _addListener(target, type, listener, prepend) {
         // To avoid recursion in the case that type === "newListener"! Before
         // adding it to the listeners, first emit "newListener".
         if (events.newListener !== undefined) {
-      target.emit('newListener', type,
+            target.emit(
-                  listener.listener ? listener.listener : listener);
+                'newListener',
+                type,
+                listener.listener ? listener.listener : listener
+            );
 
             // Re-assign `events` because a newListener handler could have caused the
             // this._events to be assigned to a new object
@@ -193,8 +209,9 @@ function _addListener(target, type, listener, prepend) {
     } else {
         if (typeof existing === 'function') {
             // Adding the second element, need to change to array.
-      existing = events[type] =
+            existing = events[type] = prepend
-        prepend ? [listener, existing] : [existing, listener];
+                ? [listener, existing]
+                : [existing, listener];
             // If we've already got an array, just append.
         } else if (prepend) {
             existing.unshift(listener);
@@ -208,10 +225,15 @@ function _addListener(target, type, listener, prepend) {
             existing.warned = true;
             // No error code for this since it is a Warning
             // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
+            var w = new Error(
-                          existing.length + ' ' + String(type) + ' listeners ' +
+                'Possible EventEmitter memory leak detected. ' +
+                    existing.length +
+                    ' ' +
+                    String(type) +
+                    ' listeners ' +
                     'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
+                    'increase limit'
+            );
             w.name = 'MaxListenersExceededWarning';
             w.emitter = target;
             w.type = type;
@@ -229,23 +251,30 @@ EventEmitter.prototype.addListener = function addListener(type, listener) {
 
 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-EventEmitter.prototype.prependListener =
+EventEmitter.prototype.prependListener = function prependListener(
-    function prependListener(type, listener) {
+    type,
+    listener
+) {
     return _addListener(this, type, listener, true);
-    };
+};
 
 function onceWrapper() {
     if (!this.fired) {
         this.target.removeListener(this.type, this.wrapFn);
         this.fired = true;
-    if (arguments.length === 0)
+        if (arguments.length === 0) return this.listener.call(this.target);
-      return this.listener.call(this.target);
         return this.listener.apply(this.target, arguments);
     }
 }
 
 function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var state = {
+        fired: false,
+        wrapFn: undefined,
+        target: target,
+        type: type,
+        listener: listener,
+    };
     var wrapped = onceWrapper.bind(state);
     wrapped.listener = listener;
     state.wrapFn = wrapped;
@@ -258,31 +287,32 @@ EventEmitter.prototype.once = function once(type, listener) {
     return this;
 };
 
-EventEmitter.prototype.prependOnceListener =
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(
-    function prependOnceListener(type, listener) {
+    type,
+    listener
+) {
     checkListener(listener);
     this.prependListener(type, _onceWrap(this, type, listener));
     return this;
-    };
+};
 
 // Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
+EventEmitter.prototype.removeListener = function removeListener(
-    function removeListener(type, listener) {
+    type,
+    listener
+) {
     var list, events, position, i, originalListener;
 
     checkListener(listener);
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     list = events[type];
-      if (list === undefined)
+    if (list === undefined) return this;
-        return this;
 
     if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
+        if (--this._eventsCount === 0) this._events = Object.create(null);
-          this._events = Object.create(null);
         else {
             delete events[type];
             if (events.removeListener)
@@ -299,34 +329,29 @@ EventEmitter.prototype.removeListener =
             }
         }
 
-        if (position < 0)
+        if (position < 0) return this;
-          return this;
 
-        if (position === 0)
+        if (position === 0) list.shift();
-          list.shift();
         else {
             spliceOne(list, position);
         }
 
-        if (list.length === 1)
+        if (list.length === 1) events[type] = list[0];
-          events[type] = list[0];
 
         if (events.removeListener !== undefined)
             this.emit('removeListener', type, originalListener || listener);
     }
 
     return this;
-    };
+};
 
 EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners =
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-    function removeAllListeners(type) {
     var listeners, events, i;
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     // not listening for removeListener, no need to emit
     if (events.removeListener === undefined) {
@@ -334,10 +359,8 @@ EventEmitter.prototype.removeAllListeners =
             this._events = Object.create(null);
             this._eventsCount = 0;
         } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
+            if (--this._eventsCount === 0) this._events = Object.create(null);
-            this._events = Object.create(null);
+            else delete events[type];
-          else
-            delete events[type];
         }
         return this;
     }
@@ -369,23 +392,22 @@ EventEmitter.prototype.removeAllListeners =
     }
 
     return this;
-    };
+};
 
 function _listeners(target, type, unwrap) {
     var events = target._events;
 
-  if (events === undefined)
+    if (events === undefined) return [];
-    return [];
 
     var evlistener = events[type];
-  if (evlistener === undefined)
+    if (evlistener === undefined) return [];
-    return [];
 
     if (typeof evlistener === 'function')
         return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
-  return unwrap ?
+    return unwrap
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+        ? unwrapListeners(evlistener)
+        : arrayClone(evlistener, evlistener.length);
 }
 
 EventEmitter.prototype.listeners = function listeners(type) {
@@ -396,7 +418,7 @@ EventEmitter.prototype.rawListeners = function rawListeners(type) {
     return _listeners(this, type, false);
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
+EventEmitter.listenerCount = function (emitter, type) {
     if (typeof emitter.listenerCount === 'function') {
         return emitter.listenerCount(type);
     } else {
@@ -427,14 +449,12 @@ EventEmitter.prototype.eventNames = function eventNames() {
 
 function arrayClone(arr, n) {
     var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
+    for (var i = 0; i < n; ++i) copy[i] = arr[i];
-    copy[i] = arr[i];
     return copy;
 }
 
 function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
+    for (; index + 1 < list.length; index++) list[index] = list[index + 1];
-    list[index] = list[index + 1];
     list.pop();
 }
 
@@ -458,11 +478,13 @@ function once(emitter, name) {
                 emitter.removeListener('error', errorListener);
             }
             resolve([].slice.call(arguments));
-    };
+        }
 
         eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
         if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+            addErrorHandlerIfEventEmitter(emitter, errorListener, {
+                once: true,
+            });
         }
     });
 }
@@ -492,6 +514,9 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
             listener(arg);
         });
     } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+        throw new TypeError(
+            'The "emitter" argument must be of type EventEmitter. Received type ' +
+                typeof emitter
+        );
     }
 }

src/rewrite/html.js

@@ -7,32 +7,44 @@ class HTML extends EventEmitter {
         this.ctx = ctx;
         this.rewriteUrl = ctx.rewriteUrl;
         this.sourceUrl = ctx.sourceUrl;
-    };
+    }
     rewrite(str, options = {}) {
         if (!str) return str;
-        return this.recast(str, node => {
+        return this.recast(
+            str,
+            (node) => {
                 if (node.tagName) this.emit('element', node, 'rewrite');
                 if (node.attr) this.emit('attr', node, 'rewrite');
-            if (node.nodeName === '#text') this.emit('text', node, 'rewrite');
+                if (node.nodeName === '#text')
-        }, options)
+                    this.emit('text', node, 'rewrite');
-    };
+            },
+            options
+        );
+    }
     source(str, options = {}) {
         if (!str) return str;
-        return this.recast(str, node => {
+        return this.recast(
+            str,
+            (node) => {
                 if (node.tagName) this.emit('element', node, 'source');
                 if (node.attr) this.emit('attr', node, 'source');
-            if (node.nodeName === '#text') this.emit('text', node, 'source');
+                if (node.nodeName === '#text')
-        }, options)
+                    this.emit('text', node, 'source');
-    };
+            },
+            options
+        );
+    }
     recast(str, fn, options = {}) {
         try {
-            const ast = (options.document ? parse : parseFragment)(new String(str).toString());
+            const ast = (options.document ? parse : parseFragment)(
+                new String(str).toString()
+            );
             this.iterate(ast, fn, options);
             return serialize(ast);
-        } catch(e) {
+        } catch (e) {
             return str;
-        };
+        }
-    };
+    }
     iterate(ast, fn, fnOptions) {
         if (!ast) return ast;
 
@@ -41,41 +53,55 @@ class HTML extends EventEmitter {
             fn(element);
             if (ast.attrs) {
                 for (const attr of ast.attrs) {
-                    if (!attr.skip) fn(new AttributeEvent(element, attr, fnOptions));
+                    if (!attr.skip)
-                };
+                        fn(new AttributeEvent(element, attr, fnOptions));
-            };
+                }
-        };
+            }
+        }
 
         if (ast.childNodes) {
             for (const child of ast.childNodes) {
                 if (!child.skip) this.iterate(child, fn, fnOptions);
-            };
+            }
-        };
+        }
 
         if (ast.nodeName === '#text') {
-            fn(new TextEvent(ast, new P5Element(ast.parentNode), false, fnOptions));
+            fn(
-        };
+                new TextEvent(
+                    ast,
+                    new P5Element(ast.parentNode),
+                    false,
+                    fnOptions
+                )
+            );
+        }
 
         return ast;
-    };
+    }
     wrapSrcset(str, meta = this.ctx.meta) {
-        return str.split(',').map(src => {
+        return str
+            .split(',')
+            .map((src) => {
                 const parts = src.trimStart().split(' ');
                 if (parts[0]) parts[0] = this.ctx.rewriteUrl(parts[0], meta);
                 return parts.join(' ');
-        }).join(', ');
+            })
-    };
+            .join(', ');
+    }
     unwrapSrcset(str, meta = this.ctx.meta) {
-        return str.split(',').map(src => {
+        return str
+            .split(',')
+            .map((src) => {
                 const parts = src.trimStart().split(' ');
                 if (parts[0]) parts[0] = this.ctx.sourceUrl(parts[0], meta);
                 return parts.join(' ');
-        }).join(', ');
+            })
-    };
+            .join(', ');
+    }
     static parse = parse;
     static parseFragment = parseFragment;
     static serialize = serialize;
-};
+}
 
 class P5Element extends EventEmitter {
     constructor(node, stream = false, options = {}) {
@@ -83,96 +109,104 @@ class P5Element extends EventEmitter {
         this.stream = stream;
         this.node = node;
         this.options = options;
-    };
+    }
     setAttribute(name, value) {
         for (const attr of this.attrs) {
             if (attr.name === name) {
                 attr.value = value;
                 return true;
-            };
+            }
-        };
+        }
 
-        this.attrs.push(
+        this.attrs.push({
-            {
             name,
             value,
+        });
     }
-        );
-    };
     getAttribute(name) {
-        const attr = this.attrs.find(attr => attr.name === name) || {};
+        const attr = this.attrs.find((attr) => attr.name === name) || {};
         return attr.value;
-    };
+    }
     hasAttribute(name) {
-        return !!this.attrs.find(attr => attr.name === name);
+        return !!this.attrs.find((attr) => attr.name === name);
-    };
+    }
     removeAttribute(name) {
-        const i = this.attrs.findIndex(attr => attr.name === name);
+        const i = this.attrs.findIndex((attr) => attr.name === name);
         if (typeof i !== 'undefined') this.attrs.splice(i, 1);
-    };
+    }
     get tagName() {
         return this.node.tagName;
-    };
+    }
     set tagName(val) {
         this.node.tagName = val;
-    };
+    }
     get childNodes() {
         return !this.stream ? this.node.childNodes : null;
-    };
+    }
     get innerHTML() {
-        return !this.stream ? serialize(
+        return !this.stream
-            {
+            ? serialize({
                   nodeName: '#document-fragment',
                   childNodes: this.childNodes,
+              })
+            : null;
     }
-        ) : null;
-    };
     set innerHTML(val) {
         if (!this.stream) this.node.childNodes = parseFragment(val).childNodes;
-    };
-    get outerHTML() {
-        return !this.stream ? serialize(
-            {
-                nodeName: '#document-fragment',
-                childNodes: [ this ],
     }
-        ) : null;
+    get outerHTML() {
-    };
+        return !this.stream
+            ? serialize({
+                  nodeName: '#document-fragment',
+                  childNodes: [this],
+              })
+            : null;
+    }
     set outerHTML(val) {
-        if (!this.stream) this.parentNode.childNodes.splice(this.parentNode.childNodes.findIndex(node => node === this.node), 1, ...parseFragment(val).childNodes);
+        if (!this.stream)
-    };
+            this.parentNode.childNodes.splice(
+                this.parentNode.childNodes.findIndex(
+                    (node) => node === this.node
+                ),
+                1,
+                ...parseFragment(val).childNodes
+            );
+    }
     get textContent() {
         if (this.stream) return null;
 
         let str = '';
-        iterate(this.node, node => {
+        iterate(this.node, (node) => {
             if (node.nodeName === '#text') str += node.value;
         });
 
         return str;
-    };
+    }
     set textContent(val) {
-        if (!this.stream) this.node.childNodes = [ 
+        if (!this.stream)
+            this.node.childNodes = [
                 {
                     nodeName: '#text',
                     value: val,
-                parentNode: this.node 
+                    parentNode: this.node,
-            }
+                },
             ];
-    };
+    }
     get nodeName() {
         return this.node.nodeName;
     }
     get parentNode() {
-        return this.node.parentNode ? new P5Element(this.node.parentNode) : null;
+        return this.node.parentNode
-    };
+            ? new P5Element(this.node.parentNode)
+            : null;
+    }
     get attrs() {
         return this.node.attrs;
     }
     get namespaceURI() {
         return this.node.namespaceURI;
     }
-};
+}
 
 class AttributeEvent {
     constructor(node, attr, options = {}) {
@@ -180,9 +214,9 @@ class AttributeEvent {
         this.attrs = node.attrs;
         this.node = node;
         this.options = options;
-    };
+    }
     delete() {
-        const i = this.attrs.findIndex(attr => attr === this.attr);
+        const i = this.attrs.findIndex((attr) => attr === this.attr);
 
         this.attrs.splice(i, 1);
 
@@ -191,25 +225,25 @@ class AttributeEvent {
         });
 
         return true;
-    };
+    }
     get name() {
         return this.attr.name;
-    };
+    }
 
     set name(val) {
         this.attr.name = val;
-    };
+    }
     get value() {
         return this.attr.value;
-    };
+    }
 
     set value(val) {
         this.attr.value = val;
-    };
+    }
     get deleted() {
         return false;
-    };
+    }
-};
+}
 
 class TextEvent {
     constructor(node, element, stream = false, options = {}) {
@@ -217,21 +251,20 @@ class TextEvent {
         this.node = node;
         this.element = element;
         this.options = options;
-    };
+    }
     get nodeName() {
         return this.node.nodeName;
     }
     get parentNode() {
         return this.element;
-    };
+    }
     get value() {
         return this.stream ? this.node.text : this.node.value;
-    };
+    }
     set value(val) {
-
         if (this.stream) this.node.text = val;
         else this.node.value = val;
-    };
+    }
-};
+}
 
 export default HTML;

src/rewrite/index.js

@@ -4,25 +4,48 @@ import JS from './js.js';
 import setCookie from 'set-cookie-parser';
 import { xor, base64, plain } from './codecs.js';
 import mimeTypes from './mime.js';
-import { validateCookie, db, getCookies, setCookies, serialize } from './cookie.js';
+import {
-import { attributes, isUrl, isForbidden, isHtml, isSrcset, isStyle, text, injectHead, createInjection } from './rewrite.html.js'; 
+    validateCookie,
+    db,
+    getCookies,
+    setCookies,
+    serialize,
+} from './cookie.js';
+import {
+    attributes,
+    isUrl,
+    isForbidden,
+    isHtml,
+    isSrcset,
+    isStyle,
+    text,
+    injectHead,
+    createInjection,
+} from './rewrite.html.js';
 import { importStyle, url } from './rewrite.css.js';
 //import { call, destructureDeclaration, dynamicImport, getProperty, importDeclaration, setProperty, sourceMethods, wrapEval, wrapIdentifier } from './rewrite.script.js';
-import { dynamicImport, identifier, importDeclaration, property, unwrap, wrapEval } from './rewrite.script.js';
+import {
+    dynamicImport,
+    identifier,
+    importDeclaration,
+    property,
+    unwrap,
+    wrapEval,
+} from './rewrite.script.js';
 import { openDB } from 'idb';
 import parsel from './parsel.js';
 import UVClient from '../client/index.js';
 import Bowser from 'bowser';
 
-
+const valid_chars =
-const valid_chars = "!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~";
+    "!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~";
-const reserved_chars = "%";
+const reserved_chars = '%';
 
 class Ultraviolet {
     constructor(options = {}) {
         this.prefix = options.prefix || '/service/';
         //this.urlRegex = /^(#|about:|data:|mailto:|javascript:)/;
-        this.urlRegex = /^(#|about:|data:|mailto:)/
+        this.urlRegex = /^(#|about:|data:|mailto:)/;
         this.rewriteUrl = options.rewriteUrl || this.rewriteUrl;
         this.sourceUrl = options.sourceUrl || this.sourceUrl;
         this.encodeUrl = options.encodeUrl || this.encodeUrl;
@@ -42,7 +65,10 @@ class Ultraviolet {
         this.parsel = parsel;
         this.openDB = this.constructor.openDB;
         this.Bowser = this.constructor.Bowser;
-        this.client = typeof self !== 'undefined' ? new UVClient((options.window || self)) : null;
+        this.client =
+            typeof self !== 'undefined'
+                ? new UVClient(options.window || self)
+                : null;
         this.master = '__uv';
         this.dataPrefix = '__uv$';
         this.attributePrefix = '__uv';
@@ -65,71 +91,82 @@ class Ultraviolet {
             serialize,
             setCookie,
         };
-    };
+    }
     rewriteUrl(str, meta = this.meta) {
         str = new String(str).trim();
         if (!str || this.urlRegex.test(str)) return str;
 
         if (str.startsWith('javascript:')) {
-            return 'javascript:' + this.js.rewrite(str.slice('javascript:'.length));
+            return (
-        };
+                'javascript:' + this.js.rewrite(str.slice('javascript:'.length))
+            );
+        }
 
         try {
-            return meta.origin + this.prefix + this.encodeUrl(new URL(str, meta.base).href);
+            return (
-        } catch(e) {
+                meta.origin +
+                this.prefix +
+                this.encodeUrl(new URL(str, meta.base).href)
+            );
+        } catch (e) {
             return meta.origin + this.prefix + this.encodeUrl(str);
-        };
+        }
-    };
+    }
     sourceUrl(str, meta = this.meta) {
         if (!str || this.urlRegex.test(str)) return str;
         try {
             return new URL(
-                this.decodeUrl(str.slice(this.prefix.length + meta.origin.length)),
+                this.decodeUrl(
+                    str.slice(this.prefix.length + meta.origin.length)
+                ),
                 meta.base
             ).href;
-        } catch(e) {
+        } catch (e) {
-            return this.decodeUrl(str.slice(this.prefix.length + meta.origin.length));
+            return this.decodeUrl(
-        };
+                str.slice(this.prefix.length + meta.origin.length)
-    };
+            );
+        }
+    }
     encodeUrl(str) {
         return encodeURIComponent(str);
-    };
+    }
     decodeUrl(str) {
         return decodeURIComponent(str);
-    };
+    }
     encodeProtocol(protocol) {
         protocol = protocol.toString();
 
         let result = '';
 
-        for(let i = 0; i < protocol.length; i++){
+        for (let i = 0; i < protocol.length; i++) {
             const char = protocol[i];
 
-            if(valid_chars.includes(char) && !reserved_chars.includes(char)){
+            if (valid_chars.includes(char) && !reserved_chars.includes(char)) {
                 result += char;
-            }else{
+            } else {
                 const code = char.charCodeAt();
                 result += '%' + code.toString(16).padStart(2, 0);
             }
         }
 
         return result;
-    };
+    }
     decodeProtocol(protocol) {
-        if(typeof protocol != 'string')throw new TypeError('protocol must be a string');
+        if (typeof protocol != 'string')
+            throw new TypeError('protocol must be a string');
 
         let result = '';
 
-        for(let i = 0; i < protocol.length; i++){
+        for (let i = 0; i < protocol.length; i++) {
             const char = protocol[i];
 
-            if(char == '%'){
+            if (char == '%') {
                 const code = parseInt(protocol.slice(i + 1, i + 3), 16);
                 const decoded = String.fromCharCode(code);
 
                 result += decoded;
                 i += 2;
-            }else{
+            } else {
                 result += char;
             }
         }
@@ -151,31 +188,31 @@ class Ultraviolet {
         wrapEval(this);
         identifier(this);
         unwrap(this);
-    };
+    }
     get rewriteHtml() {
         return this.html.rewrite.bind(this.html);
-    };
+    }
     get sourceHtml() {
         return this.html.source.bind(this.html);
-    };
+    }
     get rewriteCSS() {
         return this.css.rewrite.bind(this.css);
-    };
+    }
     get sourceCSS() {
         return this.css.source.bind(this.css);
-    };
+    }
     get rewriteJS() {
         return this.js.rewrite.bind(this.js);
-    };
+    }
     get sourceJS() {
         return this.js.source.bind(this.js);
-    };
+    }
     static codec = { xor, base64, plain };
     static mime = mimeTypes;
     static setCookie = setCookie;
     static openDB = openDB;
     static Bowser = Bowser;
-};
+}
 
 export default Ultraviolet;
 if (typeof self === 'object') self.Ultraviolet = Ultraviolet;

src/rewrite/js.js

@@ -27,13 +27,13 @@ class JS extends EventEmitter {
         };
         this.parse = parseScript /*parse*/;
         this.generate = generate;
-    };  
+    }
     rewrite(str, data = {}) {
         return this.recast(str, data, 'rewrite');
-    };
+    }
     source(str, data = {}) {
         return this.recast(str, data, 'source');
-    };
+    }
     recast(str, data = {}, type = '') {
         try {
             const output = [];
@@ -56,19 +56,26 @@ class JS extends EventEmitter {
                 this.emit(node.type, node, meta, type);
             });
 
-            meta.changes.sort((a, b) => (a.start - b.start) || (a.end - b.end));
+            meta.changes.sort((a, b) => a.start - b.start || a.end - b.end);
 
             for (const change of meta.changes) {
-                if ('start' in change && typeof change.start === 'number') output.push(str.slice(slice, change.start));
+                if ('start' in change && typeof change.start === 'number')
-                if (change.node) output.push(typeof change.node === 'string' ? change.node : generate(change.node, this.generationOptions));
+                    output.push(str.slice(slice, change.start));
-                if ('end' in change && typeof change.end === 'number') slice = change.end;
+                if (change.node)
-            };
+                    output.push(
+                        typeof change.node === 'string'
+                            ? change.node
+                            : generate(change.node, this.generationOptions)
+                    );
+                if ('end' in change && typeof change.end === 'number')
+                    slice = change.end;
+            }
             output.push(str.slice(slice));
             return output.join('');
-        } catch(e) {
+        } catch (e) {
             return str;
-        };
+        }
-    };
+    }
     iterate(ast, handler) {
         if (typeof ast != 'object' || !handler) return;
         walk(ast, null, handler);
@@ -78,16 +85,16 @@ class JS extends EventEmitter {
             for (const child in node) {
                 if (child === 'parent') continue;
                 if (Array.isArray(node[child])) {
-                    node[child].forEach(entry => { 
+                    node[child].forEach((entry) => {
-                        if (entry) walk(entry, node, handler)
+                        if (entry) walk(entry, node, handler);
                     });
                 } else {
                     if (node[child]) walk(node[child], node, handler);
-                };
+                }
-            };
+            }
             if (typeof node.iterateEnd === 'function') node.iterateEnd();
-        };
+        }
-    };
+    }
-};
+}
 
 export default JS;

src/rewrite/mime.js

@@ -5,18 +5,18 @@
  * MIT Licensed
  */
 
-'use strict'
+'use strict';
 
 /**
  * Module dependencies.
  * @private
  */
 
-var $exports = {}
+var $exports = {};
 
-import db from "mime-db";
+import db from 'mime-db';
 
-var extname = function(path = '') {
+var extname = function (path = '') {
     if (!path.includes('.')) return '';
     const map = path.split('.');
 
@@ -28,24 +28,24 @@ var extname = function(path = '') {
  * @private
  */
 
-var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
-var TEXT_TYPE_REGEXP = /^text\//i
+var TEXT_TYPE_REGEXP = /^text\//i;
 
 /**
  * Module exports.
  * @public
  */
 
-$exports.charset = charset
+$exports.charset = charset;
-$exports.charsets = { lookup: charset }
+$exports.charsets = { lookup: charset };
-$exports.contentType = contentType
+$exports.contentType = contentType;
-$exports.extension = extension
+$exports.extension = extension;
-$exports.extensions = Object.create(null)
+$exports.extensions = Object.create(null);
-$exports.lookup = lookup
+$exports.lookup = lookup;
-$exports.types = Object.create(null)
+$exports.types = Object.create(null);
 
 // Populate the extensions/types maps
-populateMaps($exports.extensions, $exports.types)
+populateMaps($exports.extensions, $exports.types);
 
 /**
  * Get the default charset for a MIME type.
@@ -54,25 +54,25 @@ populateMaps($exports.extensions, $exports.types)
  * @return {boolean|string}
  */
 
-function charset (type) {
+function charset(type) {
     if (!type || typeof type !== 'string') {
-    return false
+        return false;
     }
 
     // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
+    var match = EXTRACT_TYPE_REGEXP.exec(type);
-  var mime = match && db[match[1].toLowerCase()]
+    var mime = match && db[match[1].toLowerCase()];
 
     if (mime && mime.charset) {
-    return mime.charset
+        return mime.charset;
     }
 
     // default text/* to utf-8
     if (match && TEXT_TYPE_REGEXP.test(match[1])) {
-    return 'UTF-8'
+        return 'UTF-8';
     }
 
-  return false
+    return false;
 }
 
 /**
@@ -82,27 +82,25 @@ function charset (type) {
  * @return {boolean|string}
  */
 
-function contentType (str) {
+function contentType(str) {
     // TODO: should this even be in this module?
     if (!str || typeof str !== 'string') {
-    return false
+        return false;
     }
 
-  var mime = str.indexOf('/') === -1
+    var mime = str.indexOf('/') === -1 ? $exports.lookup(str) : str;
-    ? $exports.lookup(str)
-    : str
 
     if (!mime) {
-    return false
+        return false;
     }
 
     // TODO: use content-type or other module
     if (mime.indexOf('charset') === -1) {
-    var charset = $exports.charset(mime)
+        var charset = $exports.charset(mime);
-    if (charset) mime += '; charset=' + charset.toLowerCase()
+        if (charset) mime += '; charset=' + charset.toLowerCase();
     }
 
-  return mime
+    return mime;
 }
 
 /**
@@ -112,22 +110,22 @@ function contentType (str) {
  * @return {boolean|string}
  */
 
-function extension (type) {
+function extension(type) {
     if (!type || typeof type !== 'string') {
-    return false
+        return false;
     }
 
     // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
+    var match = EXTRACT_TYPE_REGEXP.exec(type);
 
     // get extensions
-  var exts = match && $exports.extensions[match[1].toLowerCase()]
+    var exts = match && $exports.extensions[match[1].toLowerCase()];
 
     if (!exts || !exts.length) {
-    return false
+        return false;
     }
 
-  return exts[0]
+    return exts[0];
 }
 
 /**
@@ -137,21 +135,21 @@ function extension (type) {
  * @return {boolean|string}
  */
 
-function lookup (path) {
+function lookup(path) {
     if (!path || typeof path !== 'string') {
-    return false
+        return false;
     }
 
     // get the extension ("ext" or ".ext" or full path)
     var extension = extname('x.' + path)
         .toLowerCase()
-    .substr(1)
+        .substr(1);
 
     if (!extension) {
-    return false
+        return false;
     }
 
-  return $exports.types[extension] || false
+    return $exports.types[extension] || false;
 }
 
 /**
@@ -159,40 +157,44 @@ function lookup (path) {
  * @private
  */
 
-function populateMaps (extensions, types) {
+function populateMaps(extensions, types) {
     // source preference (least -> most)
-  var preference = ['nginx', 'apache', undefined, 'iana']
+    var preference = ['nginx', 'apache', undefined, 'iana'];
 
-  Object.keys(db).forEach(function forEachMimeType (type) {
+    Object.keys(db).forEach(function forEachMimeType(type) {
-    var mime = db[type]
+        var mime = db[type];
-    var exts = mime.extensions
+        var exts = mime.extensions;
 
         if (!exts || !exts.length) {
-      return
+            return;
         }
 
         // mime -> extensions
-    extensions[type] = exts
+        extensions[type] = exts;
 
         // extension -> mime
         for (var i = 0; i < exts.length; i++) {
-      var extension = exts[i]
+            var extension = exts[i];
 
             if (types[extension]) {
-        var from = preference.indexOf(db[types[extension]].source)
+                var from = preference.indexOf(db[types[extension]].source);
-        var to = preference.indexOf(mime.source)
+                var to = preference.indexOf(mime.source);
 
-        if (types[extension] !== 'application/octet-stream' &&
+                if (
-          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+                    types[extension] !== 'application/octet-stream' &&
+                    (from > to ||
+                        (from === to &&
+                            types[extension].substr(0, 12) === 'application/'))
+                ) {
                     // skip the remapping
-          continue
+                    continue;
                 }
             }
 
             // set the extension -> mime
-      types[extension] = type
+            types[extension] = type;
         }
-  })
+    });
 }
 
 export default $exports;

src/rewrite/parsel.js

@@ -2,46 +2,73 @@ export default (function (exports) {
     'use strict';
 
     const TOKENS = {
-		attribute: /\[\s*(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(?<caseSensitive>[iIsS])?\s*)?\]/gu,
+        attribute:
+            /\[\s*(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(?<caseSensitive>[iIsS])?\s*)?\]/gu,
         id: /#(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
         class: /\.(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
         comma: /\s*,\s*/g, // must be before combinator
         combinator: /\s*[\s>+~]\s*/g, // this must be after attribute
-		"pseudo-element": /::(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu, // this must be before pseudo-class
+        'pseudo-element':
-		"pseudo-class": /:(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu,
+            /::(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu, // this must be before pseudo-class
-		type: /(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)|\*/gu // this must be last
+        'pseudo-class':
+            /:(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu,
+        type: /(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)|\*/gu, // this must be last
     };
 
-	const TOKENS_WITH_PARENS = new Set(["pseudo-class", "pseudo-element"]);
+    const TOKENS_WITH_PARENS = new Set(['pseudo-class', 'pseudo-element']);
-	const TOKENS_WITH_STRINGS = new Set([...TOKENS_WITH_PARENS, "attribute"]);
+    const TOKENS_WITH_STRINGS = new Set([...TOKENS_WITH_PARENS, 'attribute']);
-	const TRIM_TOKENS = new Set(["combinator", "comma"]);
+    const TRIM_TOKENS = new Set(['combinator', 'comma']);
-	const RECURSIVE_PSEUDO_CLASSES = new Set(["not", "is", "where", "has", "matches", "-moz-any", "-webkit-any", "nth-child", "nth-last-child"]);
+    const RECURSIVE_PSEUDO_CLASSES = new Set([
+        'not',
+        'is',
+        'where',
+        'has',
+        'matches',
+        '-moz-any',
+        '-webkit-any',
+        'nth-child',
+        'nth-last-child',
+    ]);
 
     const RECURSIVE_PSEUDO_CLASSES_ARGS = {
-		"nth-child": /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/
+        'nth-child': /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/,
     };
 
-	RECURSIVE_PSEUDO_CLASSES["nth-last-child"] = RECURSIVE_PSEUDO_CLASSES_ARGS["nth-child"];
+    RECURSIVE_PSEUDO_CLASSES['nth-last-child'] =
+        RECURSIVE_PSEUDO_CLASSES_ARGS['nth-child'];
 
     const TOKENS_FOR_RESTORE = Object.assign({}, TOKENS);
-	TOKENS_FOR_RESTORE["pseudo-element"] = RegExp(TOKENS["pseudo-element"].source.replace("(?<argument>¶+)", "(?<argument>.+?)"), "gu");
+    TOKENS_FOR_RESTORE['pseudo-element'] = RegExp(
-	TOKENS_FOR_RESTORE["pseudo-class"] = RegExp(TOKENS["pseudo-class"].source.replace("(?<argument>¶+)", "(?<argument>.+)"), "gu");
+        TOKENS['pseudo-element'].source.replace(
+            '(?<argument>¶+)',
+            '(?<argument>.+?)'
+        ),
+        'gu'
+    );
+    TOKENS_FOR_RESTORE['pseudo-class'] = RegExp(
+        TOKENS['pseudo-class'].source.replace(
+            '(?<argument>¶+)',
+            '(?<argument>.+)'
+        ),
+        'gu'
+    );
 
     function gobbleParens(text, i) {
-		let str = "", stack = [];
+        let str = '',
+            stack = [];
 
         for (; i < text.length; i++) {
             let char = text[i];
 
-			if (char === "(") {
+            if (char === '(') {
                 stack.push(char);
-			}
+            } else if (char === ')') {
-			else if (char === ")") {
                 if (stack.length > 0) {
                     stack.pop();
-				}
+                } else {
-				else {
+                    throw new Error(
-					throw new Error("Closing paren without opening paren at " + i);
+                        'Closing paren without opening paren at ' + i
+                    );
                 }
             }
 
@@ -52,10 +79,10 @@ export default (function (exports) {
             }
         }
 
-		throw new Error("Opening paren without closing paren");
+        throw new Error('Opening paren without closing paren');
     }
 
-	function tokenizeBy (text, grammar) {
+    function tokenizeBy(text, grammar) {
         if (!text) {
             return [];
         }
@@ -65,10 +92,11 @@ export default (function (exports) {
         for (var token in grammar) {
             let pattern = grammar[token];
 
-			for (var i=0; i < strarr.length; i++) { // Don’t cache length as it changes during the loop
+            for (var i = 0; i < strarr.length; i++) {
+                // Don’t cache length as it changes during the loop
                 var str = strarr[i];
 
-				if (typeof str === "string") {
+                if (typeof str === 'string') {
                     pattern.lastIndex = 0;
 
                     var match = pattern.exec(str);
@@ -86,7 +114,7 @@ export default (function (exports) {
                         args.push({
                             type: token,
                             content,
-							...match.groups
+                            ...match.groups,
                         });
 
                         let after = str.slice(from + content.length + 1);
@@ -96,21 +124,20 @@ export default (function (exports) {
 
                         strarr.splice(i, 1, ...args);
                     }
-
                 }
             }
         }
 
         let offset = 0;
-		for (let i=0; i<strarr.length; i++) {
+        for (let i = 0; i < strarr.length; i++) {
             let token = strarr[i];
             let length = token.length || token.content.length;
 
-			if (typeof token === "object") {
+            if (typeof token === 'object') {
                 token.pos = [offset, offset + length];
 
                 if (TRIM_TOKENS.has(token.type)) {
-					token.content = token.content.trim() || " ";
+                    token.content = token.content.trim() || ' ';
                 }
             }
 
@@ -120,7 +147,7 @@ export default (function (exports) {
         return strarr;
     }
 
-	function tokenize (selector) {
+    function tokenize(selector) {
         if (!selector) {
             return null;
         }
@@ -130,17 +157,27 @@ export default (function (exports) {
         // Replace strings with whitespace strings (to preserve offsets)
         let strings = [];
         // FIXME Does not account for escaped backslashes before a quote
-		selector = selector.replace(/(['"])(\\\1|.)+?\1/g, (str, quote, content, start) => {
+        selector = selector.replace(
-			strings.push({str, start});
+            /(['"])(\\\1|.)+?\1/g,
-			return quote + "§".repeat(content.length) + quote;
+            (str, quote, content, start) => {
-		});
+                strings.push({ str, start });
+                return quote + '§'.repeat(content.length) + quote;
+            }
+        );
 
         // Now that strings are out of the way, extract parens and replace them with parens with whitespace (to preserve offsets)
-		let parens = [], offset = 0, start;
+        let parens = [],
-		while ((start = selector.indexOf("(", offset)) > -1) {
+            offset = 0,
+            start;
+        while ((start = selector.indexOf('(', offset)) > -1) {
             let str = gobbleParens(selector, start);
-			parens.push({str, start});
+            parens.push({ str, start });
-			selector = selector.substring(0, start) + "(" + "¶".repeat(str.length - 2) + ")" + selector.substring(start + str.length);
+            selector =
+                selector.substring(0, start) +
+                '(' +
+                '¶'.repeat(str.length - 2) +
+                ')' +
+                selector.substring(start + str.length);
             offset = start + str.length;
         }
 
@@ -151,14 +188,21 @@ export default (function (exports) {
         function restoreNested(strings, regex, types) {
             for (let str of strings) {
                 for (let token of tokens) {
-					if (types.has(token.type) && token.pos[0] < str.start && str.start < token.pos[1]) {
+                    if (
+                        types.has(token.type) &&
+                        token.pos[0] < str.start &&
+                        str.start < token.pos[1]
+                    ) {
                         let content = token.content;
                         token.content = token.content.replace(regex, str.str);
 
-						if (token.content !== content) { // actually changed?
+                        if (token.content !== content) {
+                            // actually changed?
                             // Re-evaluate groups
                             TOKENS_FOR_RESTORE[token.type].lastIndex = 0;
-							let match = TOKENS_FOR_RESTORE[token.type].exec(token.content);
+                            let match = TOKENS_FOR_RESTORE[token.type].exec(
+                                token.content
+                            );
                             let groups = match.groups;
                             Object.assign(token, groups);
                         }
@@ -174,46 +218,45 @@ export default (function (exports) {
     }
 
     // Convert a flat list of tokens into a tree of complex & compound selectors
-	function nestTokens(tokens, {list = true} = {}) {
+    function nestTokens(tokens, { list = true } = {}) {
-		if (list && tokens.find(t => t.type === "comma")) {
+        if (list && tokens.find((t) => t.type === 'comma')) {
-			let selectors = [], temp = [];
+            let selectors = [],
+                temp = [];
 
-			for (let i=0; i<tokens.length; i++) {
+            for (let i = 0; i < tokens.length; i++) {
-				if (tokens[i].type === "comma") {
+                if (tokens[i].type === 'comma') {
                     if (temp.length === 0) {
-						throw new Error("Incorrect comma at " + i);
+                        throw new Error('Incorrect comma at ' + i);
                     }
 
-					selectors.push(nestTokens(temp, {list: false}));
+                    selectors.push(nestTokens(temp, { list: false }));
                     temp.length = 0;
-				}
+                } else {
-				else {
                     temp.push(tokens[i]);
                 }
             }
 
             if (temp.length === 0) {
-				throw new Error("Trailing comma");
+                throw new Error('Trailing comma');
-			}
+            } else {
-			else {
+                selectors.push(nestTokens(temp, { list: false }));
-				selectors.push(nestTokens(temp, {list: false}));
             }
 
-			return { type: "list", list: selectors };
+            return { type: 'list', list: selectors };
         }
 
-		for (let i=tokens.length - 1; i>=0; i--) {
+        for (let i = tokens.length - 1; i >= 0; i--) {
             let token = tokens[i];
 
-			if (token.type === "combinator") {
+            if (token.type === 'combinator') {
                 let left = tokens.slice(0, i);
                 let right = tokens.slice(i + 1);
 
                 return {
-					type: "complex",
+                    type: 'complex',
                     combinator: token.content,
                     left: nestTokens(left),
-					right: nestTokens(right)
+                    right: nestTokens(right),
                 };
             }
         }
@@ -223,9 +266,11 @@ export default (function (exports) {
         }
 
         // If we're here, there are no combinators, so it's just a list
-		return tokens.length === 1? tokens[0] : {
+        return tokens.length === 1
-			type: "compound",
+            ? tokens[0]
-			list: [...tokens] // clone to avoid pointers messing up the AST
+            : {
+                  type: 'compound',
+                  list: [...tokens], // clone to avoid pointers messing up the AST
               };
     }
 
@@ -235,16 +280,14 @@ export default (function (exports) {
             return;
         }
 
-		if (node.type === "complex") {
+        if (node.type === 'complex') {
             walk(node.left, callback, o, node);
             walk(node.right, callback, o, node);
-		}
+        } else if (node.type === 'compound') {
-		else if (node.type === "compound") {
             for (let n of node.list) {
                 walk(n, callback, o, node);
             }
-		}
+        } else if (node.subtree && o && o.subtree) {
-		else if (node.subtree && o && o.subtree) {
             walk(node.subtree, callback, o, node);
         }
 
@@ -257,21 +300,22 @@ export default (function (exports) {
      * @param options.recursive {Boolean} Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true.
      * @param options.list {Boolean} Whether this can be a selector list (A, B, C etc). Defaults to true.
      */
-	function parse(selector, {recursive = true, list = true} = {}) {
+    function parse(selector, { recursive = true, list = true } = {}) {
         let tokens = tokenize(selector);
 
         if (!tokens) {
             return null;
         }
 
-		let ast = nestTokens(tokens, {list});
+        let ast = nestTokens(tokens, { list });
 
         if (recursive) {
-			walk(ast, node => {
+            walk(ast, (node) => {
-				if (node.type === "pseudo-class" && node.argument) {
+                if (node.type === 'pseudo-class' && node.argument) {
                     if (RECURSIVE_PSEUDO_CLASSES.has(node.name)) {
                         let argument = node.argument;
-						const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[node.name];
+                        const childArg =
+                            RECURSIVE_PSEUDO_CLASSES_ARGS[node.name];
                         if (childArg) {
                             const match = childArg.exec(argument);
                             if (!match) {
@@ -282,7 +326,10 @@ export default (function (exports) {
                             argument = match.groups.subtree;
                         }
                         if (argument) {
-							node.subtree = parse(argument, {recursive: true, list: true});
+                            node.subtree = parse(argument, {
+                                recursive: true,
+                                list: true,
+                            });
                         }
                     }
                 }
@@ -295,65 +342,72 @@ export default (function (exports) {
     function specificityToNumber(specificity, base) {
         base = base || Math.max(...specificity) + 1;
 
-		return specificity[0] * base ** 2 + specificity[1] * base + specificity[2];
+        return (
+            specificity[0] * base ** 2 + specificity[1] * base + specificity[2]
+        );
     }
 
     function maxIndexOf(arr) {
-		let max = arr[0], ret = 0;
+        let max = arr[0],
+            ret = 0;
 
-		for (let i=0; i<arr.length; i++) {
+        for (let i = 0; i < arr.length; i++) {
             if (arr[i] > max) {
                 ret = i;
                 max = arr[i];
             }
         }
 
-		return arr.length === 0? -1 : ret;
+        return arr.length === 0 ? -1 : ret;
     }
 
     /**
      * Calculate specificity of a selector.
      * If the selector is a list, the max specificity is returned.
      */
-	function specificity(selector, {format = "array"} = {}) {
+    function specificity(selector, { format = 'array' } = {}) {
-		let ast = typeof selector === "object"? selector : parse(selector, {recursive: true});
+        let ast =
+            typeof selector === 'object'
+                ? selector
+                : parse(selector, { recursive: true });
 
         if (!ast) {
             return null;
         }
 
-		if (ast.type === "list") {
+        if (ast.type === 'list') {
             // Return max specificity
             let base = 10;
-			let specificities = ast.list.map(s => {
+            let specificities = ast.list.map((s) => {
                 let sp = specificity(s);
                 base = Math.max(base, ...sp);
                 return sp;
             });
-			let numbers = specificities.map(s => specificityToNumber(s, base));
+            let numbers = specificities.map((s) =>
+                specificityToNumber(s, base)
+            );
             let i = maxIndexOf(numbers);
             return specificities[i];
         }
 
         let ret = [0, 0, 0];
 
-		walk(ast, node => {
+        walk(ast, (node) => {
-			if (node.type === "id") {
+            if (node.type === 'id') {
                 ret[0]++;
-			}
+            } else if (node.type === 'class' || node.type === 'attribute') {
-			else if (node.type === "class" || node.type === "attribute") {
                 ret[1]++;
-			}
+            } else if (
-			else if ((node.type === "type" && node.content !== "*") || node.type === "pseudo-element") {
+                (node.type === 'type' && node.content !== '*') ||
+                node.type === 'pseudo-element'
+            ) {
                 ret[2]++;
-			}
+            } else if (node.type === 'pseudo-class' && node.name !== 'where') {
-			else if (node.type === "pseudo-class" && node.name !== "where") {
                 if (RECURSIVE_PSEUDO_CLASSES.has(node.name) && node.subtree) {
                     // Max of argument list
                     let sub = specificity(node.subtree);
-					sub.forEach((s, i) => ret[i] += s);
+                    sub.forEach((s, i) => (ret[i] += s));
-				}
+                } else {
-				else {
                     ret[1]++;
                 }
             }
@@ -378,5 +432,4 @@ export default (function (exports) {
     Object.defineProperty(exports, '__esModule', { value: true });
 
     return exports;
-
+})({});
-}({}));

src/rewrite/rewrite.css.js

@@ -1,9 +1,12 @@
 function url(ctx) {
     const { css } = ctx;
     css.on('Url', (node, data, type) => {
-        node.value = type === 'rewrite' ? ctx.rewriteUrl(node.value) : ctx.sourceUrl(node.value);
+        node.value =
+            type === 'rewrite'
+                ? ctx.rewriteUrl(node.value)
+                : ctx.sourceUrl(node.value);
     });
-};
+}
 
 function importStyle(ctx) {
     const { css } = ctx;
@@ -12,9 +15,11 @@ function importStyle(ctx) {
         const { data: url } = node.prelude.children.head;
         // Already handling Url's
         if (url.type === 'Url') return false;
-        url.value = type === 'rewrite' ? ctx.rewriteUrl(url.value) : ctx.sourceUrl(url.value);
+        url.value =
-
+            type === 'rewrite'
+                ? ctx.rewriteUrl(url.value)
+                : ctx.sourceUrl(url.value);
     });
-};
+}
 
 export { url, importStyle };

src/rewrite/rewrite.html.js

@@ -3,20 +3,23 @@ function attributes(ctx, meta = ctx.meta) {
     const origPrefix = attributePrefix + '-attr-';
 
     html.on('attr', (attr, type) => {
-        if (attr.node.tagName === 'base' && attr.name === 'href' && attr.options.document) {
+        if (
+            attr.node.tagName === 'base' &&
+            attr.name === 'href' &&
+            attr.options.document
+        ) {
             meta.base = new URL(attr.value, meta.url);
-        };
+        }
 
         if (type === 'rewrite' && isUrl(attr.name, attr.tagName)) {
             attr.node.setAttribute(origPrefix + attr.name, attr.value);
             attr.value = ctx.rewriteUrl(attr.value, meta);
-        };
+        }
 
         if (type === 'rewrite' && isSrcset(attr.name)) {
             attr.node.setAttribute(origPrefix + attr.name, attr.value);
             attr.value = html.wrapSrcset(attr.value, meta);
-        };
+        }
-
 
         if (type === 'rewrite' && isHtml(attr.name)) {
             attr.node.setAttribute(origPrefix + attr.name, attr.value);
@@ -25,28 +28,29 @@ function attributes(ctx, meta = ctx.meta) {
                 document: true,
                 injectHead: attr.options.injectHead || [],
             });
-        };
+        }
-
 
         if (type === 'rewrite' && isStyle(attr.name)) {
             attr.node.setAttribute(origPrefix + attr.name, attr.value);
-            attr.value = ctx.rewriteCSS(attr.value, { context: 'declarationList', });
+            attr.value = ctx.rewriteCSS(attr.value, {
-        };
+                context: 'declarationList',
+            });
+        }
 
         if (type === 'rewrite' && isForbidden(attr.name)) {
             attr.name = origPrefix + attr.name;
-        };
+        }
 
         if (type === 'rewrite' && isEvent(attr.name)) {
             attr.node.setAttribute(origPrefix + attr.name, attr.value);
             attr.value = js.rewrite(attr.value, meta);
-        };
+        }
 
         if (type === 'source' && attr.name.startsWith(origPrefix)) {
-            if (attr.node.hasAttribute(attr.name.slice(origPrefix.length))) attr.node.removeAttribute(attr.name.slice(origPrefix.length));
+            if (attr.node.hasAttribute(attr.name.slice(origPrefix.length)))
+                attr.node.removeAttribute(attr.name.slice(origPrefix.length));
             attr.name = attr.name.slice(origPrefix.length);
-        };
+        }
-
 
         /*
         if (isHtml(attr.name)) {
@@ -62,30 +66,47 @@ function attributes(ctx, meta = ctx.meta) {
         };
         */
     });
-
+}
-};
-
 
 function text(ctx, meta = ctx.meta) {
     const { html, js, css, attributePrefix } = ctx;
 
     html.on('text', (text, type) => {
         if (text.element.tagName === 'script') {
-            text.value = type === 'rewrite' ? js.rewrite(text.value) : js.source(text.value);
+            text.value =
-        };
+                type === 'rewrite'
+                    ? js.rewrite(text.value)
+                    : js.source(text.value);
+        }
 
         if (text.element.tagName === 'style') {
-            text.value = type === 'rewrite' ? css.rewrite(text.value) : css.source(text.value);
+            text.value =
-        };
+                type === 'rewrite'
+                    ? css.rewrite(text.value)
+                    : css.source(text.value);
+        }
     });
     return true;
-};
+}
 
 function isUrl(name, tag) {
-    return tag === 'object' && name === 'data' || ['src', 'href', 'ping', 'movie', 'action', 'poster', 'profile', 'background'].indexOf(name) > -1;
+    return (
-};
+        (tag === 'object' && name === 'data') ||
+        [
+            'src',
+            'href',
+            'ping',
+            'movie',
+            'action',
+            'poster',
+            'profile',
+            'background',
+        ].indexOf(name) > -1
+    );
+}
 function isEvent(name) {
-    return [
+    return (
+        [
             'onafterprint',
             'onbeforeprint',
             'onbeforeunload',
@@ -155,8 +176,9 @@ function isEvent(name) {
             'ontimeupdate',
             'onvolumechange',
             'onwaiting',
-    ].indexOf(name) > -1;
+        ].indexOf(name) > -1
-};
+    );
+}
 
 function injectHead(ctx) {
     const { html, js, css, attributePrefix } = ctx;
@@ -166,13 +188,17 @@ function injectHead(ctx) {
         if (element.tagName !== 'head') return false;
         if (!('injectHead' in element.options)) return false;
 
-        element.childNodes.unshift(
+        element.childNodes.unshift(...element.options.injectHead);
-            ...element.options.injectHead
-        );
     });
-};
+}
 
-function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', config = '/uv.config.js', cookies = '', referrer = '') {
+function createInjection(
+    handler = '/uv.handler.js',
+    bundle = '/uv.bundle.js',
+    config = '/uv.config.js',
+    cookies = '',
+    referrer = ''
+) {
     return [
         {
             tagName: 'script',
@@ -180,7 +206,9 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
             childNodes: [
                 {
                     nodeName: '#text',
-                    value: `window.__uv$cookies = atob("${btoa(cookies)}");\nwindow.__uv$referrer = atob("${btoa(referrer)}");`
+                    value: `window.__uv$cookies = atob("${btoa(
+                        cookies
+                    )}");\nwindow.__uv$referrer = atob("${btoa(referrer)}");`,
                 },
             ],
             attrs: [
@@ -188,7 +216,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
                     name: '__uv-script',
                     value: '1',
                     skip: true,
-                }
+                },
             ],
             skip: true,
         },
@@ -202,7 +230,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
                     name: '__uv-script',
                     value: '1',
                     skip: true,
-                }
+                },
             ],
         },
         {
@@ -215,7 +243,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
                     name: '__uv-script',
                     value: '1',
                     skip: true,
-                }
+                },
             ],
         },
         {
@@ -228,27 +256,41 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
                     name: '__uv-script',
                     value: '1',
                     skip: true,
-                }
+                },
             ],
-        }
+        },
     ];
-};
+}
 
 function isForbidden(name) {
-    return ['http-equiv', 'integrity', 'sandbox', 'nonce', 'crossorigin'].indexOf(name) > -1;
+    return (
-};
+        ['http-equiv', 'integrity', 'sandbox', 'nonce', 'crossorigin'].indexOf(
+            name
+        ) > -1
+    );
+}
 
-function isHtml(name){
+function isHtml(name) {
     return name === 'srcdoc';
-};
+}
 
 function isStyle(name) {
     return name === 'style';
-};
+}
 
 function isSrcset(name) {
     return name === 'srcset' || name === 'imagesrcset';
+}
+
+export {
+    attributes,
+    createInjection,
+    text,
+    isUrl,
+    isEvent,
+    isForbidden,
+    isHtml,
+    isStyle,
+    isSrcset,
+    injectHead,
 };
-
-
-export { attributes, createInjection, text, isUrl, isEvent, isForbidden, isHtml, isStyle, isSrcset, injectHead };

src/rewrite/rewrite.script.js

@@ -10,92 +10,167 @@ function property(ctx) {
                 node: '__uv.$wrap((',
                 start: node.property.start,
                 end: node.property.start,
-            })
+            });
-            node.iterateEnd = function() {
+            node.iterateEnd = function () {
                 data.changes.push({
                     node: '))',
                     start: node.property.end,
                     end: node.property.end,
                 });
             };
+        }
 
-        };
+        if (
-    
+            (!node.computed &&
-        if (!node.computed && node.property.name === 'location' && type === 'rewrite' || node.property.name === '__uv$location' && type === 'source') {
+                node.property.name === 'location' &&
+                type === 'rewrite') ||
+            (node.property.name === '__uv$location' && type === 'source')
+        ) {
             data.changes.push({
                 start: node.property.start,
                 end: node.property.end,
-                node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$location' : 'location'
+                node:
+                    type === 'rewrite'
+                        ? '__uv$setSource(__uv).__uv$location'
+                        : 'location',
             });
-        };
+        }
 
-
+        if (
-        if (!node.computed && node.property.name === 'top' && type === 'rewrite' || node.property.name === '__uv$top' && type === 'source') {
+            (!node.computed &&
+                node.property.name === 'top' &&
+                type === 'rewrite') ||
+            (node.property.name === '__uv$top' && type === 'source')
+        ) {
             data.changes.push({
                 start: node.property.start,
                 end: node.property.end,
-                node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$top' : 'top'
+                node:
+                    type === 'rewrite'
+                        ? '__uv$setSource(__uv).__uv$top'
+                        : 'top',
             });
-        };
+        }
 
-        if (!node.computed && node.property.name === 'parent' && type === 'rewrite' || node.property.name === '__uv$parent' && type === 'source') {
+        if (
+            (!node.computed &&
+                node.property.name === 'parent' &&
+                type === 'rewrite') ||
+            (node.property.name === '__uv$parent' && type === 'source')
+        ) {
             data.changes.push({
                 start: node.property.start,
                 end: node.property.end,
-                node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$parent' : 'parent'
+                node:
+                    type === 'rewrite'
+                        ? '__uv$setSource(__uv).__uv$parent'
+                        : 'parent',
             });
-        };
+        }
 
-
+        if (
-        if (!node.computed && node.property.name === 'postMessage' && type === 'rewrite') {
+            !node.computed &&
+            node.property.name === 'postMessage' &&
+            type === 'rewrite'
+        ) {
             data.changes.push({
                 start: node.property.start,
                 end: node.property.end,
-                node:'__uv$setSource(__uv).postMessage',
+                node: '__uv$setSource(__uv).postMessage',
             });
-        };
+        }
 
-
+        if (
-        if (!node.computed && node.property.name === 'eval' && type === 'rewrite' || node.property.name === '__uv$eval' && type === 'source') {
+            (!node.computed &&
+                node.property.name === 'eval' &&
+                type === 'rewrite') ||
+            (node.property.name === '__uv$eval' && type === 'source')
+        ) {
             data.changes.push({
                 start: node.property.start,
                 end: node.property.end,
-                node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$eval' : 'eval'
+                node:
+                    type === 'rewrite'
+                        ? '__uv$setSource(__uv).__uv$eval'
+                        : 'eval',
             });
-        };
+        }
 
-        if (!node.computed && node.property.name === '__uv$setSource' && type === 'source' && node.parent.type === Syntax.CallExpression) {
+        if (
+            !node.computed &&
+            node.property.name === '__uv$setSource' &&
+            type === 'source' &&
+            node.parent.type === Syntax.CallExpression
+        ) {
             const { parent, property } = node;
             data.changes.push({
                 start: property.start - 1,
                 end: parent.end,
             });
 
-            node.iterateEnd = function() {
+            node.iterateEnd = function () {
                 data.changes.push({
                     start: property.start,
                     end: parent.end,
                 });
             };
-        };
+        }
     });
-};
+}
 
 function identifier(ctx) {
     const { js } = ctx;
     js.on('Identifier', (node, data, type) => {
         if (type !== 'rewrite') return false;
         const { parent } = node;
-        if (!['location', 'eval', 'parent', 'top'].includes(node.name)) return false;
+        if (!['location', 'eval', 'parent', 'top'].includes(node.name))
-        if (parent.type === Syntax.VariableDeclarator && parent.id === node) return false;
+            return false;
-        if ((parent.type === Syntax.AssignmentExpression || parent.type === Syntax.AssignmentPattern) && parent.left === node) return false;
+        if (parent.type === Syntax.VariableDeclarator && parent.id === node)
-        if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration) && parent.id === node) return false;
+            return false;
-        if (parent.type === Syntax.MemberExpression && parent.property === node && !parent.computed) return false;
+        if (
-        if (node.name === 'eval' && parent.type === Syntax.CallExpression && parent.callee === node) return false;
+            (parent.type === Syntax.AssignmentExpression ||
-        if (parent.type === Syntax.Property && parent.key === node) return false;
+                parent.type === Syntax.AssignmentPattern) &&
-        if (parent.type === Syntax.Property && parent.value === node && parent.shorthand) return false;
+            parent.left === node
-        if (parent.type === Syntax.UpdateExpression && (parent.operator === '++' || parent.operator === '--')) return false;
+        )
-        if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration || parent.type === Syntax.ArrowFunctionExpression) && parent.params.indexOf(node) !== -1) return false;
+            return false;
+        if (
+            (parent.type === Syntax.FunctionExpression ||
+                parent.type === Syntax.FunctionDeclaration) &&
+            parent.id === node
+        )
+            return false;
+        if (
+            parent.type === Syntax.MemberExpression &&
+            parent.property === node &&
+            !parent.computed
+        )
+            return false;
+        if (
+            node.name === 'eval' &&
+            parent.type === Syntax.CallExpression &&
+            parent.callee === node
+        )
+            return false;
+        if (parent.type === Syntax.Property && parent.key === node)
+            return false;
+        if (
+            parent.type === Syntax.Property &&
+            parent.value === node &&
+            parent.shorthand
+        )
+            return false;
+        if (
+            parent.type === Syntax.UpdateExpression &&
+            (parent.operator === '++' || parent.operator === '--')
+        )
+            return false;
+        if (
+            (parent.type === Syntax.FunctionExpression ||
+                parent.type === Syntax.FunctionDeclaration ||
+                parent.type === Syntax.ArrowFunctionExpression) &&
+            parent.params.indexOf(node) !== -1
+        )
+            return false;
         if (parent.type === Syntax.MethodDefinition) return false;
         if (parent.type === Syntax.ClassDeclaration) return false;
         if (parent.type === Syntax.RestElement) return false;
@@ -105,10 +180,10 @@ function identifier(ctx) {
         data.changes.push({
             start: node.start,
             end: node.end,
-            node: '__uv.$get(' + node.name + ')'
+            node: '__uv.$get(' + node.name + ')',
         });
     });
-};
+}
 
 function wrapEval(ctx) {
     const { js } = ctx;
@@ -118,14 +193,14 @@ function wrapEval(ctx) {
         if (node.callee.type !== 'Identifier') return false;
         if (node.callee.name !== 'eval') return false;
 
-        const [ script ] = node.arguments;
+        const [script] = node.arguments;
 
         data.changes.push({
             node: '__uv.js.rewrite(',
             start: script.start,
             end: script.start,
-        })
+        });
-        node.iterateEnd = function() {
+        node.iterateEnd = function () {
             data.changes.push({
                 node: ')',
                 start: script.end,
@@ -133,21 +208,31 @@ function wrapEval(ctx) {
             });
         };
     });
-};
+}
 
 function importDeclaration(ctx) {
     const { js } = ctx;
     js.on(Syntax.Literal, (node, data, type) => {
-        if (!((node.parent.type === Syntax.ImportDeclaration || node.parent.type === Syntax.ExportAllDeclaration || node.parent.type === Syntax.ExportNamedDeclaration) 
+        if (
-        && node.parent.source === node)) return false;
+            !(
+                (node.parent.type === Syntax.ImportDeclaration ||
+                    node.parent.type === Syntax.ExportAllDeclaration ||
+                    node.parent.type === Syntax.ExportNamedDeclaration) &&
+                node.parent.source === node
+            )
+        )
+            return false;
 
         data.changes.push({
             start: node.start + 1,
             end: node.end - 1,
-            node: type === 'rewrite' ? ctx.rewriteUrl(node.value) : ctx.sourceUrl(node.value)
+            node:
+                type === 'rewrite'
+                    ? ctx.rewriteUrl(node.value)
+                    : ctx.sourceUrl(node.value),
         });
     });
-};
+}
 
 function dynamicImport(ctx) {
     const { js } = ctx;
@@ -157,8 +242,8 @@ function dynamicImport(ctx) {
             node: '__uv.rewriteUrl(',
             start: node.source.start,
             end: node.source.start,
-        })
+        });
-        node.iterateEnd = function() {
+        node.iterateEnd = function () {
             data.changes.push({
                 node: ')',
                 start: node.source.end,
@@ -166,7 +251,7 @@ function dynamicImport(ctx) {
             });
         };
     });
-};
+}
 
 function unwrap(ctx) {
     const { js } = ctx;
@@ -174,17 +259,22 @@ function unwrap(ctx) {
         if (type !== 'source') return false;
         if (!isWrapped(node.callee)) return false;
 
-        switch(node.callee.property.name) {
+        switch (node.callee.property.name) {
             case '$wrap':
-                if (!node.arguments || node.parent.type !== Syntax.MemberExpression || node.parent.property !== node) return false;
+                if (
-                const [ property ] = node.arguments;
+                    !node.arguments ||
+                    node.parent.type !== Syntax.MemberExpression ||
+                    node.parent.property !== node
+                )
+                    return false;
+                const [property] = node.arguments;
 
                 data.changes.push({
                     start: node.callee.start,
                     end: property.start,
                 });
 
-                node.iterateEnd = function() {
+                node.iterateEnd = function () {
                     data.changes.push({
                         start: node.end - 2,
                         end: node.end,
@@ -193,14 +283,14 @@ function unwrap(ctx) {
                 break;
             case '$get':
             case 'rewriteUrl':
-                const [ arg ] = node.arguments;
+                const [arg] = node.arguments;
 
                 data.changes.push({
                     start: node.callee.start,
                     end: arg.start,
                 });
 
-                node.iterateEnd = function() {
+                node.iterateEnd = function () {
                     data.changes.push({
                         start: node.end - 1,
                         end: node.end,
@@ -208,36 +298,43 @@ function unwrap(ctx) {
                 };
                 break;
             case 'rewrite':
-                const [ script ] = node.arguments;
+                const [script] = node.arguments;
                 data.changes.push({
                     start: node.callee.start,
                     end: script.start,
                 });
-                node.iterateEnd = function() {
+                node.iterateEnd = function () {
                     data.changes.push({
                         start: node.end - 1,
                         end: node.end,
                     });
                 };
-        };
+        }
-
     });
-};
+}
 
 function isWrapped(node) {
     if (node.type !== Syntax.MemberExpression) return false;
     if (node.property.name === 'rewrite' && isWrapped(node.object)) return true;
-    if (node.object.type !== Syntax.Identifier || node.object.name !== '__uv') return false;
+    if (node.object.type !== Syntax.Identifier || node.object.name !== '__uv')
-    if (!['js', '$get', '$wrap', 'rewriteUrl'].includes(node.property.name)) return false;
+        return false;
+    if (!['js', '$get', '$wrap', 'rewriteUrl'].includes(node.property.name))
+        return false;
     return true;
-};
+}
 
 function computedProperty(parent) {
     if (!parent.computed) return false;
     const { property: node } = parent;
     if (node.type === 'Literal' && !['location', 'top', 'parent']) return false;
     return true;
+}
+
+export {
+    property,
+    wrapEval,
+    dynamicImport,
+    importDeclaration,
+    identifier,
+    unwrap,
 };
-
-
-export { property, wrapEval, dynamicImport, importDeclaration, identifier, unwrap };

src/uv.sw.js

@@ -5,7 +5,10 @@ class UVServiceWorker extends EventEmitter {
     constructor(config = __uv$config) {
         super();
         if (!config.bare) config.bare = '/bare/';
-        this.addresses = typeof config.bare === 'string' ? [ new URL(config.bare, location) ] : config.bare.map(str => new URL(str, location));
+        this.addresses =
+            typeof config.bare === 'string'
+                ? [new URL(config.bare, location)]
+                : config.bare.map((str) => new URL(str, location));
         this.headers = {
             csp: [
                 'cross-origin-embedder-policy',
@@ -25,82 +28,101 @@ class UVServiceWorker extends EventEmitter {
                 'x-powered-by',
                 'x-xss-protection',
             ],
-            forward: [
+            forward: ['accept-encoding', 'connection', 'content-length'],
-                'accept-encoding', 
-                'connection',
-                'content-length',
-            ],
         };
         this.method = {
-            empty: [
+            empty: ['GET', 'HEAD'],
-                'GET',
-                'HEAD'
-            ]
         };
         this.statusCode = {
-            empty: [ 
+            empty: [204, 304],
-                204,
-                304,
-            ],
         };
         this.config = config;
-        this.browser = Ultraviolet.Bowser.getParser(self.navigator.userAgent).getBrowserName();
+        this.browser = Ultraviolet.Bowser.getParser(
+            self.navigator.userAgent
+        ).getBrowserName();
 
         if (this.browser === 'Firefox') {
             this.headers.forward.push('user-agent');
             this.headers.forward.push('content-type');
-        };
+        }
-    };
+    }
     async fetch({ request }) {
-        if (!request.url.startsWith(location.origin + (this.config.prefix || '/service/'))) {
+        if (
+            !request.url.startsWith(
+                location.origin + (this.config.prefix || '/service/')
+            )
+        ) {
             return fetch(request);
-        };
+        }
         try {
-
             const ultraviolet = new Ultraviolet(this.config);
 
             if (typeof this.config.construct === 'function') {
                 this.config.construct(ultraviolet, 'service');
-            };
+            }
 
             const db = await ultraviolet.cookie.db();
 
             ultraviolet.meta.origin = location.origin;
-            ultraviolet.meta.base = ultraviolet.meta.url = new URL(ultraviolet.sourceUrl(request.url));
+            ultraviolet.meta.base = ultraviolet.meta.url = new URL(
+                ultraviolet.sourceUrl(request.url)
+            );
 
             const requestCtx = new RequestContext(
                 request,
                 this,
                 ultraviolet,
-                !this.method.empty.includes(request.method.toUpperCase()) ? await request.blob() : null
+                !this.method.empty.includes(request.method.toUpperCase())
+                    ? await request.blob()
+                    : null
             );
 
             if (ultraviolet.meta.url.protocol === 'blob:') {
                 requestCtx.blob = true;
-                requestCtx.base = requestCtx.url = new URL(requestCtx.url.pathname);
+                requestCtx.base = requestCtx.url = new URL(
-            };
+                    requestCtx.url.pathname
+                );
+            }
 
-            if (request.referrer && request.referrer.startsWith(location.origin)) {
+            if (
-                const referer = new URL(ultraviolet.sourceUrl(request.referrer));
+                request.referrer &&
+                request.referrer.startsWith(location.origin)
+            ) {
+                const referer = new URL(
+                    ultraviolet.sourceUrl(request.referrer)
+                );
 
-                if (requestCtx.headers.origin || ultraviolet.meta.url.origin !== referer.origin && request.mode === 'cors') {
+                if (
+                    requestCtx.headers.origin ||
+                    (ultraviolet.meta.url.origin !== referer.origin &&
+                        request.mode === 'cors')
+                ) {
                     requestCtx.headers.origin = referer.origin;
-                };
+                }
 
                 requestCtx.headers.referer = referer.href;
-            };
+            }
 
-            const cookies = await ultraviolet.cookie.getCookies(db) || [];
+            const cookies = (await ultraviolet.cookie.getCookies(db)) || [];
-            const cookieStr = ultraviolet.cookie.serialize(cookies, ultraviolet.meta, false);
+            const cookieStr = ultraviolet.cookie.serialize(
+                cookies,
+                ultraviolet.meta,
+                false
+            );
 
-            if (this.browser === 'Firefox' && !(request.destination === 'iframe' || request.destination === 'document')) {
+            if (
+                this.browser === 'Firefox' &&
+                !(
+                    request.destination === 'iframe' ||
+                    request.destination === 'document'
+                )
+            ) {
                 requestCtx.forward.shift();
-            };
+            }
 
             if (cookieStr) requestCtx.headers.cookie = cookieStr;
             requestCtx.headers.Host = requestCtx.url.host;
 
-
             const reqEvent = new HookEvent(requestCtx, null, null);
             this.emit('request', reqEvent);
 
@@ -110,7 +132,7 @@ class UVServiceWorker extends EventEmitter {
 
             if (response.status === 500) {
                 return Promise.reject('');
-            };
+            }
 
             const responseCtx = new ResponseContext(requestCtx, response, this);
             const resEvent = new HookEvent(responseCtx, null, null);
@@ -120,16 +142,24 @@ class UVServiceWorker extends EventEmitter {
 
             for (const name of this.headers.csp) {
                 if (responseCtx.headers[name]) delete responseCtx.headers[name];
-            }; 
+            }
 
             if (responseCtx.headers.location) {
-                responseCtx.headers.location = ultraviolet.rewriteUrl(responseCtx.headers.location);
+                responseCtx.headers.location = ultraviolet.rewriteUrl(
-            };
+                    responseCtx.headers.location
+                );
+            }
 
             if (responseCtx.headers['set-cookie']) {
-                Promise.resolve(ultraviolet.cookie.setCookies(responseCtx.headers['set-cookie'], db, ultraviolet.meta)).then(() => {
+                Promise.resolve(
-                    self.clients.matchAll().then(function (clients){
+                    ultraviolet.cookie.setCookies(
-                        clients.forEach(function(client){
+                        responseCtx.headers['set-cookie'],
+                        db,
+                        ultraviolet.meta
+                    )
+                ).then(() => {
+                    self.clients.matchAll().then(function (clients) {
+                        clients.forEach(function (client) {
                             client.postMessage({
                                 msg: 'updateCookies',
                                 url: ultraviolet.meta.url.href,
@@ -138,10 +168,10 @@ class UVServiceWorker extends EventEmitter {
                     });
                 });
                 delete responseCtx.headers['set-cookie'];
-            };
+            }
 
             if (responseCtx.body) {
-                switch(request.destination) {
+                switch (request.destination) {
                     case 'script':
                     case 'worker':
                         responseCtx.body = `if (!self.__uv && self.importScripts) importScripts('${__uv$config.bundle}', '${__uv$config.config}', '${__uv$config.handler}');\n`;
@@ -156,27 +186,36 @@ class UVServiceWorker extends EventEmitter {
                         break;
                     case 'iframe':
                     case 'document':
-                        if (isHtml(ultraviolet.meta.url, (responseCtx.headers['content-type'] || ''))) {
+                        if (
+                            isHtml(
+                                ultraviolet.meta.url,
+                                responseCtx.headers['content-type'] || ''
+                            )
+                        ) {
                             responseCtx.body = ultraviolet.rewriteHtml(
                                 await response.text(),
                                 {
-                                    document: true ,
+                                    document: true,
                                     injectHead: ultraviolet.createHtmlInject(
                                         this.config.handler,
                                         this.config.bundle,
                                         this.config.config,
-                                        ultraviolet.cookie.serialize(cookies, ultraviolet.meta, true), 
+                                        ultraviolet.cookie.serialize(
+                                            cookies,
+                                            ultraviolet.meta,
+                                            true
+                                        ),
                                         request.referrer
-                                    )
+                                    ),
                                 }
                             );
-                        };
+                        }
-                };
+                }
-            };
+            }
 
             if (requestCtx.headers.accept === 'text/event-stream') {
                 responseCtx.headers['content-type'] = 'text/event-stream';
-            };
+            }
 
             this.emit('response', resEvent);
             if (resEvent.intercepted) return resEvent.returnValue;
@@ -186,40 +225,46 @@ class UVServiceWorker extends EventEmitter {
                 status: responseCtx.status,
                 statusText: responseCtx.statusText,
             });
-
+        } catch (err) {
-        } catch(err) {
             return new Response(err.toString(), {
                 status: 500,
             });
-        };
+        }
-    };
+    }
     getBarerResponse(response) {
         const headers = {};
         const raw = JSON.parse(response.headers.get('x-bare-headers'));
 
         for (const key in raw) {
             headers[key.toLowerCase()] = raw[key];
-        };
+        }
 
         return {
             headers,
             status: +response.headers.get('x-bare-status'),
             statusText: response.headers.get('x-bare-status-text'),
-            body: !this.statusCode.empty.includes(+response.headers.get('x-bare-status')) ? response.body : null,
+            body: !this.statusCode.empty.includes(
-        };
+                +response.headers.get('x-bare-status')
+            )
+                ? response.body
+                : null,
         };
+    }
     get address() {
-        return this.addresses[Math.floor(Math.random() * this.addresses.length)];
+        return this.addresses[
-    };
+            Math.floor(Math.random() * this.addresses.length)
+        ];
+    }
     static Ultraviolet = Ultraviolet;
-};
+}
 
 self.UVServiceWorker = UVServiceWorker;
 
-
 class ResponseContext {
     constructor(request, response, worker) {
-        const { headers, status, statusText, body } = !request.blob ? worker.getBarerResponse(response) : {
+        const { headers, status, statusText, body } = !request.blob
+            ? worker.getBarerResponse(response)
+            : {
                   status: response.status,
                   statusText: response.statusText,
                   headers: Object.fromEntries([...response.headers.entries()]),
@@ -232,17 +277,17 @@ class ResponseContext {
         this.status = status;
         this.statusText = statusText;
         this.body = body;
-    };
+    }
     get url() {
         return this.request.url;
     }
     get base() {
         return this.request.base;
-    };
+    }
     set base(val) {
         this.request.base = val;
-    };
+    }
-};
+}
 
 class RequestContext {
     constructor(request, worker, ultraviolet, body = null) {
@@ -257,41 +302,56 @@ class RequestContext {
         this.credentials = 'omit';
         this.mode = request.mode === 'cors' ? request.mode : 'same-origin';
         this.blob = false;
-    };
+    }
     get send() {
-        return new Request((!this.blob ? this.address.href + 'v1/' : 'blob:' + location.origin + this.url.pathname), {
+        return new Request(
+            !this.blob
+                ? this.address.href + 'v1/'
+                : 'blob:' + location.origin + this.url.pathname,
+            {
                 method: this.method,
                 headers: {
                     'x-bare-protocol': this.url.protocol,
                     'x-bare-host': this.url.hostname,
                     'x-bare-path': this.url.pathname + this.url.search,
-                'x-bare-port': this.url.port || (this.url.protocol === 'https:' ? '443' : '80'),
+                    'x-bare-port':
+                        this.url.port ||
+                        (this.url.protocol === 'https:' ? '443' : '80'),
                     'x-bare-headers': JSON.stringify(this.headers),
                     'x-bare-forward-headers': JSON.stringify(this.forward),
                 },
                 redirect: this.redirect,
                 credentials: this.credentials,
-            mode: location.origin !== this.address.origin ? 'cors' : this.mode,
+                mode:
-            body: this.body
+                    location.origin !== this.address.origin
-        });
+                        ? 'cors'
-    };
+                        : this.mode,
+                body: this.body,
+            }
+        );
+    }
     get url() {
         return this.ultraviolet.meta.url;
-    };
+    }
     set url(val) {
         this.ultraviolet.meta.url = val;
-    };
+    }
     get base() {
         return this.ultraviolet.meta.base;
-    };
+    }
     set base(val) {
         this.ultraviolet.meta.base = val;
-    };
+    }
 }
 
 function isHtml(url, contentType = '') {
-    return (Ultraviolet.mime.contentType((contentType  || url.pathname)) || 'text/html').split(';')[0] === 'text/html';
+    return (
-};
+        (
+            Ultraviolet.mime.contentType(contentType || url.pathname) ||
+            'text/html'
+        ).split(';')[0] === 'text/html'
+    );
+}
 
 class HookEvent {
     #intercepted;
@@ -302,33 +362,35 @@ class HookEvent {
         this.data = data;
         this.target = target;
         this.that = that;
-    };
+    }
     get intercepted() {
         return this.#intercepted;
-    };
+    }
     get returnValue() {
         return this.#returnValue;
-    };
+    }
     respondWith(input) {
         this.#returnValue = input;
         this.#intercepted = true;
-    };
+    }
-};  
+}
 
-var R = typeof Reflect === 'object' ? Reflect : null
+var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function'
+var ReflectApply =
+    R && typeof R.apply === 'function'
         ? R.apply
         : function ReflectApply(target, receiver, args) {
               return Function.prototype.apply.call(target, receiver, args);
-  }
+          };
 
-var ReflectOwnKeys
+var ReflectOwnKeys;
 if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
+    ReflectOwnKeys = R.ownKeys;
 } else if (Object.getOwnPropertySymbols) {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
+        return Object.getOwnPropertyNames(target).concat(
-      .concat(Object.getOwnPropertySymbols(target));
+            Object.getOwnPropertySymbols(target)
+        );
     };
 } else {
     ReflectOwnKeys = function ReflectOwnKeys(target) {
@@ -340,9 +402,11 @@ function ProcessEmitWarning(warning) {
     if (console && console.warn) console.warn(warning);
 }
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+var NumberIsNaN =
+    Number.isNaN ||
+    function NumberIsNaN(value) {
         return value !== value;
-}
+    };
 
 function EventEmitter() {
     EventEmitter.init.call(this);
@@ -361,27 +425,35 @@ var defaultMaxListeners = 10;
 
 function checkListener(listener) {
     if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+        throw new TypeError(
+            'The "listener" argument must be of type Function. Received type ' +
+                typeof listener
+        );
     }
 }
 
 Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
     enumerable: true,
-  get: function() {
+    get: function () {
         return defaultMaxListeners;
     },
-  set: function(arg) {
+    set: function (arg) {
         if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+            throw new RangeError(
+                'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
+                    arg +
+                    '.'
+            );
         }
         defaultMaxListeners = arg;
-  }
+    },
 });
 
-EventEmitter.init = function() {
+EventEmitter.init = function () {
-
+    if (
-  if (this._events === undefined ||
+        this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
+        this._events === Object.getPrototypeOf(this)._events
+    ) {
         this._events = Object.create(null);
         this._eventsCount = 0;
     }
@@ -393,7 +465,11 @@ EventEmitter.init = function() {
 // that to be increased. Set to zero for unlimited.
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
     if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+        throw new RangeError(
+            'The value of "n" is out of range. It must be a non-negative number. Received ' +
+                n +
+                '.'
+        );
     }
     this._maxListeners = n;
     return this;
@@ -412,42 +488,39 @@ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
 EventEmitter.prototype.emit = function emit(type) {
     var args = [];
     for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+    var doError = type === 'error';
 
     var events = this._events;
-  if (events !== undefined)
+    if (events !== undefined) doError = doError && events.error === undefined;
-    doError = (doError && events.error === undefined);
+    else if (!doError) return false;
-  else if (!doError)
-    return false;
 
     // If there is no 'error' event listener then throw.
     if (doError) {
         var er;
-    if (args.length > 0)
+        if (args.length > 0) er = args[0];
-      er = args[0];
         if (er instanceof Error) {
             // Note: The comments on the `throw` lines are intentional, they show
             // up in Node's output if this results in an unhandled exception.
             throw er; // Unhandled 'error' event
         }
         // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+        var err = new Error(
+            'Unhandled error.' + (er ? ' (' + er.message + ')' : '')
+        );
         err.context = er;
         throw err; // Unhandled 'error' event
     }
 
     var handler = events[type];
 
-  if (handler === undefined)
+    if (handler === undefined) return false;
-    return false;
 
     if (typeof handler === 'function') {
         ReflectApply(handler, this, args);
     } else {
         var len = handler.length;
         var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
+        for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
-      ReflectApply(listeners[i], this, args);
     }
 
     return true;
@@ -468,8 +541,11 @@ function _addListener(target, type, listener, prepend) {
         // To avoid recursion in the case that type === "newListener"! Before
         // adding it to the listeners, first emit "newListener".
         if (events.newListener !== undefined) {
-      target.emit('newListener', type,
+            target.emit(
-                  listener.listener ? listener.listener : listener);
+                'newListener',
+                type,
+                listener.listener ? listener.listener : listener
+            );
 
             // Re-assign `events` because a newListener handler could have caused the
             // this._events to be assigned to a new object
@@ -485,8 +561,9 @@ function _addListener(target, type, listener, prepend) {
     } else {
         if (typeof existing === 'function') {
             // Adding the second element, need to change to array.
-      existing = events[type] =
+            existing = events[type] = prepend
-        prepend ? [listener, existing] : [existing, listener];
+                ? [listener, existing]
+                : [existing, listener];
             // If we've already got an array, just append.
         } else if (prepend) {
             existing.unshift(listener);
@@ -500,10 +577,15 @@ function _addListener(target, type, listener, prepend) {
             existing.warned = true;
             // No error code for this since it is a Warning
             // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
+            var w = new Error(
-                          existing.length + ' ' + String(type) + ' listeners ' +
+                'Possible EventEmitter memory leak detected. ' +
+                    existing.length +
+                    ' ' +
+                    String(type) +
+                    ' listeners ' +
                     'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
+                    'increase limit'
+            );
             w.name = 'MaxListenersExceededWarning';
             w.emitter = target;
             w.type = type;
@@ -521,23 +603,30 @@ EventEmitter.prototype.addListener = function addListener(type, listener) {
 
 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-EventEmitter.prototype.prependListener =
+EventEmitter.prototype.prependListener = function prependListener(
-    function prependListener(type, listener) {
+    type,
+    listener
+) {
     return _addListener(this, type, listener, true);
-    };
+};
 
 function onceWrapper() {
     if (!this.fired) {
         this.target.removeListener(this.type, this.wrapFn);
         this.fired = true;
-    if (arguments.length === 0)
+        if (arguments.length === 0) return this.listener.call(this.target);
-      return this.listener.call(this.target);
         return this.listener.apply(this.target, arguments);
     }
 }
 
 function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var state = {
+        fired: false,
+        wrapFn: undefined,
+        target: target,
+        type: type,
+        listener: listener,
+    };
     var wrapped = onceWrapper.bind(state);
     wrapped.listener = listener;
     state.wrapFn = wrapped;
@@ -550,31 +639,32 @@ EventEmitter.prototype.once = function once(type, listener) {
     return this;
 };
 
-EventEmitter.prototype.prependOnceListener =
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(
-    function prependOnceListener(type, listener) {
+    type,
+    listener
+) {
     checkListener(listener);
     this.prependListener(type, _onceWrap(this, type, listener));
     return this;
-    };
+};
 
 // Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
+EventEmitter.prototype.removeListener = function removeListener(
-    function removeListener(type, listener) {
+    type,
+    listener
+) {
     var list, events, position, i, originalListener;
 
     checkListener(listener);
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     list = events[type];
-      if (list === undefined)
+    if (list === undefined) return this;
-        return this;
 
     if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
+        if (--this._eventsCount === 0) this._events = Object.create(null);
-          this._events = Object.create(null);
         else {
             delete events[type];
             if (events.removeListener)
@@ -591,34 +681,29 @@ EventEmitter.prototype.removeListener =
             }
         }
 
-        if (position < 0)
+        if (position < 0) return this;
-          return this;
 
-        if (position === 0)
+        if (position === 0) list.shift();
-          list.shift();
         else {
             spliceOne(list, position);
         }
 
-        if (list.length === 1)
+        if (list.length === 1) events[type] = list[0];
-          events[type] = list[0];
 
         if (events.removeListener !== undefined)
             this.emit('removeListener', type, originalListener || listener);
     }
 
     return this;
-    };
+};
 
 EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners =
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-    function removeAllListeners(type) {
     var listeners, events, i;
 
     events = this._events;
-      if (events === undefined)
+    if (events === undefined) return this;
-        return this;
 
     // not listening for removeListener, no need to emit
     if (events.removeListener === undefined) {
@@ -626,10 +711,8 @@ EventEmitter.prototype.removeAllListeners =
             this._events = Object.create(null);
             this._eventsCount = 0;
         } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
+            if (--this._eventsCount === 0) this._events = Object.create(null);
-            this._events = Object.create(null);
+            else delete events[type];
-          else
-            delete events[type];
         }
         return this;
     }
@@ -661,23 +744,22 @@ EventEmitter.prototype.removeAllListeners =
     }
 
     return this;
-    };
+};
 
 function _listeners(target, type, unwrap) {
     var events = target._events;
 
-  if (events === undefined)
+    if (events === undefined) return [];
-    return [];
 
     var evlistener = events[type];
-  if (evlistener === undefined)
+    if (evlistener === undefined) return [];
-    return [];
 
     if (typeof evlistener === 'function')
         return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
-  return unwrap ?
+    return unwrap
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+        ? unwrapListeners(evlistener)
+        : arrayClone(evlistener, evlistener.length);
 }
 
 EventEmitter.prototype.listeners = function listeners(type) {
@@ -688,7 +770,7 @@ EventEmitter.prototype.rawListeners = function rawListeners(type) {
     return _listeners(this, type, false);
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
+EventEmitter.listenerCount = function (emitter, type) {
     if (typeof emitter.listenerCount === 'function') {
         return emitter.listenerCount(type);
     } else {
@@ -719,14 +801,12 @@ EventEmitter.prototype.eventNames = function eventNames() {
 
 function arrayClone(arr, n) {
     var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
+    for (var i = 0; i < n; ++i) copy[i] = arr[i];
-    copy[i] = arr[i];
     return copy;
 }
 
 function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
+    for (; index + 1 < list.length; index++) list[index] = list[index + 1];
-    list[index] = list[index + 1];
     list.pop();
 }
 
@@ -750,11 +830,13 @@ function once(emitter, name) {
                 emitter.removeListener('error', errorListener);
             }
             resolve([].slice.call(arguments));
-    };
+        }
 
         eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
         if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+            addErrorHandlerIfEventEmitter(emitter, errorListener, {
+                once: true,
+            });
         }
     });
 }
@@ -784,6 +866,9 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
             listener(arg);
         });
     } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+        throw new TypeError(
+            'The "emitter" argument must be of type EventEmitter. Received type ' +
+                typeof emitter
+        );
     }
 }

webpack.config.js

@@ -11,7 +11,9 @@ const isDevelopment = process.env.NODE_ENV !== 'production';
 const config = {
     mode: isDevelopment ? 'development' : 'production',
     entry: {
-		bundle: fileURLToPath(new URL('./src/rewrite/index.js', import.meta.url)),
+        bundle: fileURLToPath(
+            new URL('./src/rewrite/index.js', import.meta.url)
+        ),
         handler: fileURLToPath(new URL('./src/uv.handler.js', import.meta.url)),
         sw: fileURLToPath(new URL('./src/uv.sw.js', import.meta.url)),
     },
@@ -31,10 +33,14 @@ const config = {
         new CopyPlugin({
             patterns: [
                 {
-					from: fileURLToPath(new URL('./src/uv.config.js', import.meta.url)),
+                    from: fileURLToPath(
+                        new URL('./src/uv.config.js', import.meta.url)
+                    ),
                 },
                 {
-					from: fileURLToPath(new URL('./src/sw.js', import.meta.url)),
+                    from: fileURLToPath(
+                        new URL('./src/sw.js', import.meta.url)
+                    ),
                 },
             ],
         }),