Base+LibJS+LibWeb: Make prettier clean

Also use "// prettier-ignore" comments where necessary rather than
excluding whole files (via .prettierignore).

.prettierignore

@@ -1,3 +0,0 @@
-classes/class-expressions.js
-functions/function-strict-mode.js
-new-expression.js

Base/res/html/misc/welcome.js

@@ -1,3 +1,3 @@
-document.addEventListener("DOMContentLoaded", function() {
+document.addEventListener("DOMContentLoaded", function () {
     document.getElementById("ua").innerHTML = navigator.userAgent;
 });

Libraries/LibJS/Tests/arguments-object.js

@@ -13,4 +13,3 @@ test("basic arguments object", () => {
     expect(bar("hello", "friends", ":^)")).toBe("friends");
     expect(bar("hello")).toBe(undefined);
 });
-

Libraries/LibJS/Tests/builtins/Array/Array.from.js

@@ -50,8 +50,9 @@ describe("normal behavior", () => {
                     let value = begin - 1;
                     return {
                         next() {
-                            if (value < end)
+                            if (value < end) {
                                 value += 1;
+                            }
                             return { value: value, done: value >= end };
                         },
                     };

Libraries/LibJS/Tests/builtins/Date/Date.js

@@ -37,7 +37,7 @@ test("tuple constructor", () => {
     expect(new Date(2019, 11).getMilliseconds()).toBe(0);
     expect(new Date(2019, 11).getDay()).toBe(0);
 
-    let date = new Date(2019, 11, 15,  9, 16, 14, 123); // Note: Month is 0-based.
+    let date = new Date(2019, 11, 15, 9, 16, 14, 123); // Note: Month is 0-based.
     expect(date.getFullYear()).toBe(2019);
     expect(date.getMonth()).toBe(11);
     expect(date.getDate()).toBe(15);
@@ -48,14 +48,14 @@ test("tuple constructor", () => {
     expect(date.getDay()).toBe(0);
 
     // getTime() returns a time stamp in UTC, but we can at least check it's in the right interval, which will be true independent of the local timezone if the range is big enough.
-    let timestamp_lower_bound = 1575072000000;  // 2019-12-01T00:00:00Z
+    let timestamp_lower_bound = 1575072000000; // 2019-12-01T00:00:00Z
-    let timestamp_upper_bound = 1577750400000;  // 2019-12-31T00:00:00Z
+    let timestamp_upper_bound = 1577750400000; // 2019-12-31T00:00:00Z
     expect(date.getTime()).toBeGreaterThan(timestamp_lower_bound);
     expect(date.getTime()).toBeLessThan(timestamp_upper_bound);
 });
 
 test("tuple constructor overflow", () => {
-    let date = new Date(2019, 13, 33,  30, 70, 80, 2345);
+    let date = new Date(2019, 13, 33, 30, 70, 80, 2345);
     expect(date.getFullYear()).toBe(2020);
     expect(date.getMonth()).toBe(2);
     expect(date.getDate()).toBe(5);
@@ -65,7 +65,7 @@ test("tuple constructor overflow", () => {
     expect(date.getMilliseconds()).toBe(345);
     expect(date.getDay()).toBe(4);
 
-    let date = new Date(2019, -13, -33,  -30, -70, -80, -2345);
+    let date = new Date(2019, -13, -33, -30, -70, -80, -2345);
     expect(date.getFullYear()).toBe(2017);
     expect(date.getMonth()).toBe(9);
     expect(date.getDate()).toBe(26);

Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-get.js

@@ -42,11 +42,14 @@ describe("[[Get]] trap normal behavior", () => {
     });
 
     test("custom receiver value", () => {
-        let p = new Proxy({}, {
+        let p = new Proxy(
-            get(target, property, receiver) {
+            {},
-                return receiver;
+            {
-            },
+                get(target, property, receiver) {
-        });
+                    return receiver;
+                },
+            }
+        );
 
         expect(Reflect.get(p, "foo", 42)).toBe(42);
     });

Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-set.js

@@ -40,7 +40,7 @@ describe("[[Set]] trap normal behavior", () => {
         expect(p.foo).toBe(20);
         p.foo = 10;
         expect(p.foo).toBe(10);
-        p[Symbol.hasInstance] = "foo"
+        p[Symbol.hasInstance] = "foo";
         expect(p[Symbol.hasInstance]).toBe("foo");
     });
 

Libraries/LibJS/Tests/builtins/RegExp/RegExp.prototype.flags.js

@@ -6,5 +6,6 @@ test("basic functionality", () => {
     expect(/foo/s.flags).toBe("s");
     expect(/foo/u.flags).toBe("u");
     expect(/foo/y.flags).toBe("y");
+    // prettier-ignore
     expect(/foo/sgimyu.flags).toBe("gimsuy");
 });

Libraries/LibJS/Tests/builtins/String/String.prototype.endsWith.js

@@ -34,6 +34,9 @@ test("basic functionality", () => {
     expect(s.endsWith("", -1)).toBeTrue();
     expect(s.endsWith("", 42)).toBeTrue();
     expect("12undefined".endsWith()).toBeTrue();
-    expect(() => s.endsWith(/foobar/)).toThrowWithMessage(TypeError, "searchString is not a string, but a regular expression");
+    expect(() => s.endsWith(/foobar/)).toThrowWithMessage(
+        TypeError,
+        "searchString is not a string, but a regular expression"
+    );
     expect(s.endsWith("bar", undefined)).toBeTrue();
 });

Libraries/LibJS/Tests/classes/class-expressions.js

@@ -1,14 +1,11 @@
-// This file must not be formatted by prettier. Make sure your IDE
-// respects the .prettierignore file!
-
 test("basic functionality", () => {
     const A = class {
         constructor(x) {
-           this.x = x;
+            this.x = x;
         }
 
         getX() {
-           return this.x * 2;
+            return this.x * 2;
         }
     };
 
@@ -16,6 +13,7 @@ test("basic functionality", () => {
 });
 
 test("inline instantiation", () => {
+    // prettier-ignore
     const a = new class {
         constructor() {
             this.x = 10;
@@ -30,6 +28,7 @@ test("inline instantiation", () => {
 });
 
 test("inline instantiation with argument", () => {
+    // prettier-ignore
     const a = new class {
         constructor(x) {
             this.x = x;
@@ -53,7 +52,7 @@ test("extending class expressions", () => {
             super(y);
             this.y = y * 2;
         }
-    };
+    }
 
     const a = new A(10);
     expect(a.x).toBe(10);
@@ -61,9 +60,9 @@ test("extending class expressions", () => {
 });
 
 test("class expression name", () => {
-    let A = class {}
+    let A = class {};
     expect(A.name).toBe("A");
 
-    let B = class C {}
+    let B = class C {};
     expect(B.name).toBe("C");
 });

Libraries/LibJS/Tests/functions/function-strict-mode.js

@@ -1,6 +1,3 @@
-// This file must not be formatted by prettier. Make sure your IDE
-// respects the .prettierignore file!
-
 test("non strict-mode by default", () => {
     expect(isStrictMode()).toBeFalse();
 });
@@ -10,21 +7,25 @@ test("use strict with double quotes", () => {
     expect(isStrictMode()).toBeTrue();
 });
 
+// prettier-ignore
 test("use strict with single quotes", () => {
     'use strict';
     expect(isStrictMode()).toBeTrue();
 });
 
+// prettier-ignore
 test("use strict with backticks does not yield strict mode", () => {
     `use strict`;
     expect(isStrictMode()).toBeFalse();
 });
 
+// prettier-ignore
 test("use strict with single quotes after statement does not yield strict mode code", () => {
     ;'use strict';
     expect(isStrictMode()).toBeFalse();
 });
 
+// prettier-ignore
 test("use strict with double quotes after statement does not yield strict mode code", () => {
     ;"use strict";
     expect(isStrictMode()).toBeFalse();
@@ -39,14 +40,14 @@ strict";
 test("strict mode propagates down the scope chain", () => {
     "use strict";
     expect(isStrictMode()).toBeTrue();
-    (function() {
+    (function () {
         expect(isStrictMode()).toBeTrue();
     })();
 });
 
 test("strict mode does not propagate up the scope chain", () => {
     expect(isStrictMode()).toBeFalse();
-    (function() {
+    (function () {
         "use strict";
         expect(isStrictMode()).toBeTrue();
     })();

Libraries/LibJS/Tests/loops/break-basic.js

@@ -10,8 +10,9 @@ test("Toplevel break inside loop", () => {
 test("break inside sub-blocks", () => {
     var j = 0;
     for (var i = 0; i < 9; ++i) {
-        if (j == 4)
+        if (j == 4) {
             break;
+        }
         ++j;
     }
     expect(j).toBe(4);

Libraries/LibJS/Tests/new-expression.js

@@ -1,6 +1,4 @@
-// This file must not be formatted by prettier. Make sure your IDE
+// prettier-ignore
-// respects the .prettierignore file!
-
 test("new-expression parsing", () => {
     function Foo() {
         this.x = 1;
@@ -21,6 +19,7 @@ test("new-expression parsing", () => {
     expect(foo).toBe("[object Object]2");
 });
 
+// prettier-ignore
 test("new-expressions with object keys", () => {
     let a = {
         b: function () {

Libraries/LibJS/Tests/parseInt.js

@@ -2,33 +2,33 @@ test("basic parseInt() functionality", () => {
     expect(parseInt("0")).toBe(0);
     expect(parseInt("100")).toBe(100);
     expect(parseInt("1000", 16)).toBe(4096);
-    expect(parseInt('0xF', 16)).toBe(15)
+    expect(parseInt("0xF", 16)).toBe(15);
-    expect(parseInt('F', 16)).toBe(15)
+    expect(parseInt("F", 16)).toBe(15);
-    expect(parseInt('17', 8)).toBe(15)
+    expect(parseInt("17", 8)).toBe(15);
-    expect(parseInt(021, 8)).toBe(15)
+    expect(parseInt(021, 8)).toBe(15);
-    expect(parseInt('015', 10)).toBe(15)
+    expect(parseInt("015", 10)).toBe(15);
-    expect(parseInt(15.99, 10)).toBe(15)
+    expect(parseInt(15.99, 10)).toBe(15);
-    expect(parseInt('15,123', 10)).toBe(15)
+    expect(parseInt("15,123", 10)).toBe(15);
-    expect(parseInt('FXX123', 16)).toBe(15)
+    expect(parseInt("FXX123", 16)).toBe(15);
-    expect(parseInt('1111', 2)).toBe(15)
+    expect(parseInt("1111", 2)).toBe(15);
-    expect(parseInt('15 * 3', 10)).toBe(15)
+    expect(parseInt("15 * 3", 10)).toBe(15);
-    expect(parseInt('15e2', 10)).toBe(15)
+    expect(parseInt("15e2", 10)).toBe(15);
-    expect(parseInt('15px', 10)).toBe(15)
+    expect(parseInt("15px", 10)).toBe(15);
-    expect(parseInt('12', 13)).toBe(15)
+    expect(parseInt("12", 13)).toBe(15);
-    expect(parseInt('Hello', 8)).toBeNaN();
+    expect(parseInt("Hello", 8)).toBeNaN();
-    expect(parseInt('546', 2)).toBeNaN();
+    expect(parseInt("546", 2)).toBeNaN();
-    expect(parseInt('-F', 16)).toBe(-15);
+    expect(parseInt("-F", 16)).toBe(-15);
-    expect(parseInt('-0F', 16)).toBe(-15);
+    expect(parseInt("-0F", 16)).toBe(-15);
-    expect(parseInt('-0XF', 16)).toBe(-15);
+    expect(parseInt("-0XF", 16)).toBe(-15);
     expect(parseInt(-15.1, 10)).toBe(-15);
-    expect(parseInt('-17', 8)).toBe(-15);
+    expect(parseInt("-17", 8)).toBe(-15);
-    expect(parseInt('-15', 10)).toBe(-15);
+    expect(parseInt("-15", 10)).toBe(-15);
-    expect(parseInt('-1111', 2)).toBe(-15);
+    expect(parseInt("-1111", 2)).toBe(-15);
-    expect(parseInt('-15e1', 10)).toBe(-15);
+    expect(parseInt("-15e1", 10)).toBe(-15);
-    expect(parseInt('-12', 13)).toBe(-15);
+    expect(parseInt("-12", 13)).toBe(-15);
     expect(parseInt(4.7, 10)).toBe(4);
-    expect(parseInt('0e0', 16)).toBe(224);
+    expect(parseInt("0e0", 16)).toBe(224);
-    expect(parseInt('123_456')).toBe(123);
+    expect(parseInt("123_456")).toBe(123);
 
     // FIXME: expect(parseInt(4.7 * 1e22, 10)).toBe(4);
     // FIXME: expect(parseInt(0.00000000000434, 10)).toBe(4);
@@ -42,10 +42,18 @@ test("basic parseInt() functionality", () => {
 });
 
 test("parseInt() radix is coerced to a number", () => {
-    const obj = { valueOf() { return 8; } };
+    const obj = {
-    expect(parseInt('11', obj)).toBe(9);
+        valueOf() {
-    obj.valueOf = function() { return 1; }
+            return 8;
-    expect(parseInt('11', obj)).toBeNaN();
+        },
-    obj.valueOf = function() { return Infinity; }
+    };
-    expect(parseInt('11', obj)).toBe(11);
+    expect(parseInt("11", obj)).toBe(9);
+    obj.valueOf = function () {
+        return 1;
+    };
+    expect(parseInt("11", obj)).toBeNaN();
+    obj.valueOf = function () {
+        return Infinity;
+    };
+    expect(parseInt("11", obj)).toBe(11);
 });

Libraries/LibJS/Tests/strict-mode-blocks.js

@@ -2,16 +2,19 @@ test("Issue #3641, strict mode should be function- or program-level, not block-l
     function func() {
         expect(isStrictMode()).toBeFalse();
 
+        // prettier-ignore
         {
             "use strict";
             expect(isStrictMode()).toBeFalse();
         }
 
+        // prettier-ignore
         if (true) {
             "use strict";
             expect(isStrictMode()).toBeFalse();
         }
 
+        // prettier-ignore
         do {
             "use strict";
             expect(isStrictMode()).toBeFalse();

Libraries/LibJS/Tests/strict-mode-errors.js

@@ -7,6 +7,9 @@ test("basic functionality", () => {
         }).toThrowWithMessage(TypeError, "Cannot assign property foo to primitive value");
         expect(() => {
             primitive[Symbol.hasInstance] = 123;
-        }).toThrowWithMessage(TypeError, "Cannot assign property Symbol(Symbol.hasInstance) to primitive value");
+        }).toThrowWithMessage(
+            TypeError,
+            "Cannot assign property Symbol(Symbol.hasInstance) to primitive value"
+        );
     });
 });

Libraries/LibJS/Tests/string-escapes.js

@@ -40,7 +40,9 @@ describe("octal escapes", () => {
         expect("\5").toBe("\u0005");
         expect("\6").toBe("\u0006");
         expect("\7").toBe("\u0007");
+        // prettier-ignore
         expect("\8").toBe("8");
+        // prettier-ignore
         expect("\9").toBe("9");
         expect("\128").toBe("\n8");
         expect("\141bc").toBe("abc");

Libraries/LibJS/Tests/test-common.js

@@ -302,7 +302,7 @@ class ExpectationError extends Error {
         // Test for syntax errors; target must be a string
         toEval() {
             this.__expect(typeof this.target === "string");
-            const success = canParseSource(this.target)
+            const success = canParseSource(this.target);
             this.__expect(this.inverted ? !success : success);
         }
 

Libraries/LibJS/Tests/use-strict-directive.js

@@ -6,6 +6,7 @@ test("valid 'use strict; directive", () => {
         })()
     ).toBeTrue();
     expect(
+        // prettier-ignore
         (() => {
             'use strict';
             return isStrictMode();

Libraries/LibJS/Tests/with-basic.js

@@ -1,5 +1,5 @@
 test("basic with statement functionality", () => {
-    var object = { "foo": 5, "bar": 6, "baz": 7 };
+    var object = { foo: 5, bar: 6, baz: 7 };
     var qux = 1;
 
     var bar = 99;

Libraries/LibWeb/Tests/HTML/HTMLElement.js

@@ -1,9 +1,9 @@
-loadPage("file:///res/html/misc/welcome.html")
+loadPage("file:///res/html/misc/welcome.html");
 
 afterInitialPageLoad(() => {
-   test("contentEditable attribute", () => {
+    test("contentEditable attribute", () => {
         expect(document.body.contentEditable).toBe("inherit");
         expect(document.firstChild.nextSibling.nodeName).toBe("html");
         expect(document.firstChild.nextSibling.contentEditable).toBe("true");
-   });
+    });
 });

Libraries/LibWeb/Tests/HTML/HTMLTemplateElement.js

@@ -4,7 +4,7 @@ afterInitialPageLoad(() => {
     test("Basic functionality", () => {
         const template = document.getElementById("template");
         expect(template).not.toBeNull();
-       
+
         // The contents of a template element are not children of the actual element.
         // The document fragment is not a child of the element either.
         expect(template.firstChild).toBeNull();
@@ -17,7 +17,7 @@ afterInitialPageLoad(() => {
         expect(templateDiv.nodeName).toBe("div");
         expect(templateDiv.textContent).toBe("Hello template!");
     });
-    
+
     test("Templates are inert (e.g. scripts won't run)", () => {
         // The page has a template element with a script element in it.
         // Templates are inert, for example, they won't run scripts.

Libraries/LibWeb/Tests/HTML/document.body.js

@@ -49,7 +49,7 @@ afterInitialPageLoad(() => {
 
     // FIXME: Add this in once removeChild is implemented.
     test.skip("Nullable", () => {
-       document.documentElement.removeChild(document.body);
+        document.documentElement.removeChild(document.body);
-       expect(document.body).toBeNull();
+        expect(document.body).toBeNull();
     });
 });

Libraries/LibWeb/Tests/test-common.js

@@ -25,7 +25,7 @@ let __AfterInitialPageLoad__ = () => {};
 let afterInitialPageLoad;
 
 (() => {
-    loadPage = (page) => __PageToLoad__ = page;
+    loadPage = page => (__PageToLoad__ = page);
-    beforeInitialPageLoad = (callback) => __BeforeInitialPageLoad__ = callback;
+    beforeInitialPageLoad = callback => (__BeforeInitialPageLoad__ = callback);
-    afterInitialPageLoad = (callback) => __AfterInitialPageLoad__ = callback;
+    afterInitialPageLoad = callback => (__AfterInitialPageLoad__ = callback);
 })();