diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..5d12634
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,13 @@
+# editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
diff --git a/main.test.js b/main.test.js
index a5ea295..6efdb6a 100644
--- a/main.test.js
+++ b/main.test.js
@@ -10,83 +10,83 @@ describe('node-memwatch', () => {
     expect(memwatch.HeapDiff).toBeDefined();
   });
 
-	describe('.gc()', () => {
-		it('causes a stats() event to be emitted', () => {
-			return new Promise((resolve) => {
-				memwatch.once('stats', (s) => {
-					expect(typeof s).toBe('object');
-					resolve();
-				});
-				memwatch.gc();
-			});
-		});
-	});
+  describe('.gc()', () => {
+    it('causes a stats() event to be emitted', () => {
+      return new Promise((resolve) => {
+        memwatch.once('stats', (s) => {
+          expect(typeof s).toBe('object');
+          resolve();
+        });
+        memwatch.gc();
+      });
+    });
+  });
 
-	describe('HeapDiff', () => {
-		it('detects allocations', () => {
-			function LeakingClass() {};
-			const arr = [];
-			const hd = new memwatch.HeapDiff();
-			for (let i = 0; i < 100; i++) arr.push(new LeakingClass());
-			const diff = hd.end();
-			expect(Array.isArray(diff.change.details)).toBe(true);
-			// find the LeakingClass elem
-			let leakingReport;
-			diff.change.details.forEach((d) => {
-				if (d.what === 'LeakingClass')
-					leakingReport = d;
-			});
-			expect(leakingReport).toBeDefined();
-			expect(leakingReport['+'] - leakingReport['-']).toBeGreaterThan(0);
-		});
+  describe('HeapDiff', () => {
+    it('detects allocations', () => {
+      function LeakingClass() {};
+      const arr = [];
+      const hd = new memwatch.HeapDiff();
+      for (let i = 0; i < 100; i++) arr.push(new LeakingClass());
+      const diff = hd.end();
+      expect(Array.isArray(diff.change.details)).toBe(true);
+      // find the LeakingClass elem
+      let leakingReport;
+      diff.change.details.forEach((d) => {
+        if (d.what === 'LeakingClass')
+          leakingReport = d;
+      });
+      expect(leakingReport).toBeDefined();
+      expect(leakingReport['+'] - leakingReport['-']).toBeGreaterThan(0);
+    });
 
-		it('has the correct output format', () => {
-			function LeakingClass() {};
-			const arr = [];
-			const hd = new memwatch.HeapDiff();
-			for (let i = 0; i < 100; i++) arr.push(new LeakingClass());
-			expect(hd.end()).toEqual(
-				expect.objectContaining({
-					after: expect.objectContaining({
-						nodes: expect.any(Number),
-						size: expect.any(String),
-						size_bytes: expect.any(Number),
-					}),
-					before: expect.objectContaining({
-						nodes: expect.any(Number),
-						size: expect.any(String),
-						size_bytes: expect.any(Number),
-					}),
-					change: expect.objectContaining({
-						allocated_nodes: expect.any(Number),
-						details: expect.arrayContaining([
-							expect.objectContaining({
-								'+': expect.any(Number),
-								'-': expect.any(Number),
-								size: expect.any(String),
-								size_bytes: expect.any(Number),
-								what: expect.any(String),
-							}),
-						]),
-						freed_nodes: expect.any(Number),
-						size: expect.any(String),
-						size_bytes: expect.any(Number),
-					}),
-				})
-			)
-		});
+    it('has the correct output format', () => {
+      function LeakingClass() {};
+      const arr = [];
+      const hd = new memwatch.HeapDiff();
+      for (let i = 0; i < 100; i++) arr.push(new LeakingClass());
+      expect(hd.end()).toEqual(
+        expect.objectContaining({
+          after: expect.objectContaining({
+            nodes: expect.any(Number),
+            size: expect.any(String),
+            size_bytes: expect.any(Number),
+          }),
+          before: expect.objectContaining({
+            nodes: expect.any(Number),
+            size: expect.any(String),
+            size_bytes: expect.any(Number),
+          }),
+          change: expect.objectContaining({
+            allocated_nodes: expect.any(Number),
+            details: expect.arrayContaining([
+              expect.objectContaining({
+                '+': expect.any(Number),
+                '-': expect.any(Number),
+                size: expect.any(String),
+                size_bytes: expect.any(Number),
+                what: expect.any(String),
+              }),
+            ]),
+            freed_nodes: expect.any(Number),
+            size: expect.any(String),
+            size_bytes: expect.any(Number),
+          }),
+        })
+      )
+    });
 
-		it('double end should throw', () => {
-			const hd = new memwatch.HeapDiff();
-			expect(() => hd.end()).not.toThrow();
-			expect(() => hd.end()).toThrow();
-		});
+    it('double end should throw', () => {
+      const hd = new memwatch.HeapDiff();
+      expect(() => hd.end()).not.toThrow();
+      expect(() => hd.end()).toThrow();
+    });
 
-		it('improper HeapDiff allocation should throw an exception', () => {
-			// equivalent to "new require('memwatch').HeapDiff()"
-			// see issue #30
-			expect(() => new (memwatch.HeapDiff())).toThrow();
-		});
-	});
+    it('improper HeapDiff allocation should throw an exception', () => {
+      // equivalent to "new require('memwatch').HeapDiff()"
+      // see issue #30
+      expect(() => new (memwatch.HeapDiff())).toThrow();
+    });
+  });
 });