LibJS: Indent tests with 4 spaces instead of 2

Author: https://github.com/mattco98
Commit: 1ef573eb30
Pull-request: https://github.com/SerenityOS/serenity/pull/2689
Reviewed-by: https://github.com/linusg

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

@@ -1,72 +1,72 @@
 describe("[[Construct]] trap normal behavior", () => {
-  test("forwarding when not defined in handler", () => {
-    let p = new Proxy(
-      function () {
-        this.x = 5;
-      },
-      { construct: null }
-    );
-    expect(new p().x).toBe(5);
-    p = new Proxy(
-      function () {
-        this.x = 5;
-      },
-      { construct: undefined }
-    );
-    expect(new p().x).toBe(5);
-    p = new Proxy(function () {
-      this.x = 5;
-    }, {});
-    expect(new p().x).toBe(5);
-  });
+    test("forwarding when not defined in handler", () => {
+        let p = new Proxy(
+            function () {
+                this.x = 5;
+            },
+            { construct: null }
+        );
+        expect(new p().x).toBe(5);
+        p = new Proxy(
+            function () {
+                this.x = 5;
+            },
+            { construct: undefined }
+        );
+        expect(new p().x).toBe(5);
+        p = new Proxy(function () {
+            this.x = 5;
+        }, {});
+        expect(new p().x).toBe(5);
+    });
 
-  test("trapping 'new'", () => {
-    function f(value) {
-      this.x = value;
-    }
+    test("trapping 'new'", () => {
+        function f(value) {
+            this.x = value;
+        }
 
-    let p;
-    const handler = {
-      construct(target, arguments, newTarget) {
-        expect(target).toBe(f);
-        expect(newTarget).toBe(p);
-        if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
-        return Reflect.construct(target, arguments, newTarget);
-      },
-    };
-    p = new Proxy(f, handler);
+        let p;
+        const handler = {
+            construct(target, arguments, newTarget) {
+                expect(target).toBe(f);
+                expect(newTarget).toBe(p);
+                if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
+                return Reflect.construct(target, arguments, newTarget);
+            },
+        };
+        p = new Proxy(f, handler);
 
-    expect(new p(15).x).toBe(15);
-    expect(new p(15, true).x).toBe(30);
-  });
+        expect(new p(15).x).toBe(15);
+        expect(new p(15, true).x).toBe(30);
+    });
 
-  test("trapping Reflect.construct", () => {
-    function f(value) {
-      this.x = value;
-    }
+    test("trapping Reflect.construct", () => {
+        function f(value) {
+            this.x = value;
+        }
 
-    let p;
-    function theNewTarget() {}
-    const handler = {
-      construct(target, arguments, newTarget) {
-        expect(target).toBe(f);
-        expect(newTarget).toBe(theNewTarget);
-        if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
-        return Reflect.construct(target, arguments, newTarget);
-      },
-    };
-    p = new Proxy(f, handler);
+        let p;
+        function theNewTarget() {}
+        const handler = {
+            construct(target, arguments, newTarget) {
+                expect(target).toBe(f);
+                expect(newTarget).toBe(theNewTarget);
+                if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
+                return Reflect.construct(target, arguments, newTarget);
+            },
+        };
+        p = new Proxy(f, handler);
 
-    Reflect.construct(p, [15], theNewTarget);
-  });
+        Reflect.construct(p, [15], theNewTarget);
+    });
 });
 
 describe("[[Construct]] invariants", () => {
-  test("target must have a [[Construct]] slot", () => {
-    [{}, [], new Proxy({}, {})].forEach(item => {
-      expect(() => {
-        new new Proxy(item, {})();
-      }).toThrowWithMessage(TypeError, "[object ProxyObject] is not a constructor");
+    test("target must have a [[Construct]] slot", () => {
+        [{}, [], new Proxy({}, {})].forEach(item => {
+            expect(() => {
+                new new Proxy(item, {})();
+            }).toThrowWithMessage(TypeError, "[object ProxyObject] is not a constructor");
+        });
     });
-  });
 });