eslint --fix

.eslintignore.errorfiles

@@ -1,15 +0,0 @@
-# autogenerated file: run scripts/generate-eslint-error-ignore-file to update.
-
-src/Markdown.js
-src/NodeAnimator.js
-src/components/structures/RoomDirectory.js
-src/components/views/rooms/MemberList.js
-src/utils/DMRoomMap.js
-src/utils/MultiInviter.js
-test/components/structures/MessagePanel-test.js
-test/components/views/dialogs/InteractiveAuthDialog-test.js
-test/mock-clock.js
-src/component-index.js
-test/end-to-end-tests/node_modules/
-test/end-to-end-tests/element/
-test/end-to-end-tests/synapse/

package.json

@@ -45,7 +45,7 @@
     "start:all": "concurrently --kill-others-on-fail --prefix \"{time} [{name}]\" -n build,reskindex \"yarn start:build\" \"yarn reskindex:watch\"",
     "start:build": "babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
     "lint": "yarn lint:types && yarn lint:js && yarn lint:style",
-    "lint:js": "eslint --max-warnings 0 --ignore-path .eslintignore.errorfiles src test",
+    "lint:js": "eslint --max-warnings 0 src test",
     "lint:types": "tsc --noEmit --jsx react",
     "lint:style": "stylelint 'res/css/**/*.scss'",
     "test": "jest",

scripts/generate-eslint-error-ignore-file

@@ -1,23 +0,0 @@
-#!/bin/sh
-#
-# generates .eslintignore.errorfiles to list the files which have errors in,
-# so that they can be ignored in future automated linting.
-
-out=.eslintignore.errorfiles
-
-cd `dirname $0`/..
-
-echo "generating $out"
-
-{
-    cat <<EOF
-# autogenerated file: run scripts/generate-eslint-error-ignore-file to update.
-
-EOF
-
-    ./node_modules/.bin/eslint -f json src test |
-        jq -r '.[] | select((.errorCount + .warningCount) > 0) | .filePath' |
-        sed -e 's/.*matrix-react-sdk\///';
-} > "$out"
-# also append rules from eslintignore file
-cat .eslintignore >> $out

test/components/structures/MessagePanel-test.js

@@ -26,7 +26,7 @@ import { EventEmitter } from "events";
 import sdk from '../../skinned-sdk';
 
 const MessagePanel = sdk.getComponent('structures.MessagePanel');
-import {MatrixClientPeg} from '../../../src/MatrixClientPeg';
+import { MatrixClientPeg } from '../../../src/MatrixClientPeg';
 import Matrix from 'matrix-js-sdk';
 
 const test_utils = require('../../test-utils');
@@ -79,7 +79,7 @@ describe('MessagePanel', function() {
     beforeEach(function() {
         test_utils.stubClient();
         client = MatrixClientPeg.get();
-        client.credentials = {userId: '@me:here'};
+        client.credentials = { userId: '@me:here' };
 
         // HACK: We assume all settings want to be disabled
         SettingsStore.getValue = jest.fn((arg) => {
@@ -120,7 +120,6 @@ describe('MessagePanel', function() {
         return events;
     }
 
-
     // make a collection of events with some member events that should be collapsed
     // with a MemberEventListSummary
     function mkMelsEvents() {

test/components/views/dialogs/InteractiveAuthDialog-test.js

@@ -20,10 +20,10 @@ import ReactTestUtils from 'react-dom/test-utils';
 import MatrixReactTestUtils from 'matrix-react-test-utils';
 
 import sdk from '../../../skinned-sdk';
-import {MatrixClientPeg} from '../../../../src/MatrixClientPeg';
+import { MatrixClientPeg } from '../../../../src/MatrixClientPeg';
 
 import * as test_utils from '../../../test-utils';
-import {sleep} from "../../../../src/utils/promise";
+import { sleep } from "../../../../src/utils/promise";
 
 const InteractiveAuthDialog = sdk.getComponent(
     'views.dialogs.InteractiveAuthDialog',
@@ -45,11 +45,11 @@ describe('InteractiveAuthDialog', function() {
 
     it('Should successfully complete a password flow', function() {
         const onFinished = jest.fn();
-        const doRequest = jest.fn().mockResolvedValue({a: 1});
+        const doRequest = jest.fn().mockResolvedValue({ a: 1 });
 
         // tell the stub matrixclient to return a real userid
         const client = MatrixClientPeg.get();
-        client.credentials = {userId: "@user:id"};
+        client.credentials = { userId: "@user:id" };
 
         const dlg = ReactDOM.render(
             <InteractiveAuthDialog
@@ -57,7 +57,7 @@ describe('InteractiveAuthDialog', function() {
                 authData={{
                     session: "sess",
                     flows: [
-                        {"stages": ["m.login.password"]},
+                        { "stages": ["m.login.password"] },
                     ],
                 }}
                 makeRequest={doRequest}
@@ -105,7 +105,7 @@ describe('InteractiveAuthDialog', function() {
             return sleep(1);
         }).then(sleep(1)).then(() => {
             expect(onFinished).toBeCalledTimes(1);
-            expect(onFinished).toBeCalledWith(true, {a: 1});
+            expect(onFinished).toBeCalledWith(true, { a: 1 });
         });
     });
 });

test/mock-clock.js

@@ -47,369 +47,366 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 const j$ = {};
 
 j$.Clock = function() {
-  function Clock(global, delayedFunctionSchedulerFactory, mockDate) {
+    function Clock(global, delayedFunctionSchedulerFactory, mockDate) {
-    let self = this,
+        const self = this;
-      realTimingFunctions = {
+        const realTimingFunctions = {
         setTimeout: global.setTimeout,
         clearTimeout: global.clearTimeout,
         setInterval: global.setInterval,
         clearInterval: global.clearInterval,
-      },
+        };
-      fakeTimingFunctions = {
+        const fakeTimingFunctions = {
         setTimeout: setTimeout,
         clearTimeout: clearTimeout,
         setInterval: setInterval,
         clearInterval: clearInterval,
-      },
+        };
-      installed = false,
+        let installed = false;
-      delayedFunctionScheduler,
+        let delayedFunctionScheduler;
-      timer;
+        let timer;
 
+        self.install = function() {
+            if (!originalTimingFunctionsIntact()) {
+                throw new Error('Jasmine Clock was unable to install over custom global timer functions. Is the clock already installed?');
+            }
+            replace(global, fakeTimingFunctions);
+            timer = fakeTimingFunctions;
+            delayedFunctionScheduler = delayedFunctionSchedulerFactory();
+            installed = true;
 
-    self.install = function() {
+            return self;
-      if(!originalTimingFunctionsIntact()) {
+        };
-        throw new Error('Jasmine Clock was unable to install over custom global timer functions. Is the clock already installed?');
-      }
-      replace(global, fakeTimingFunctions);
-      timer = fakeTimingFunctions;
-      delayedFunctionScheduler = delayedFunctionSchedulerFactory();
-      installed = true;
 
-      return self;
+        self.uninstall = function() {
-    };
+            delayedFunctionScheduler = null;
+            mockDate.uninstall();
+            replace(global, realTimingFunctions);
 
-    self.uninstall = function() {
+            timer = realTimingFunctions;
-      delayedFunctionScheduler = null;
+            installed = false;
-      mockDate.uninstall();
+        };
-      replace(global, realTimingFunctions);
 
-      timer = realTimingFunctions;
+        self.withMock = function(closure) {
-      installed = false;
+            this.install();
-    };
+            try {
+                closure();
+            } finally {
+                this.uninstall();
+            }
+        };
 
-    self.withMock = function(closure) {
+        self.mockDate = function(initialDate) {
-      this.install();
+            mockDate.install(initialDate);
-      try {
+        };
-        closure();
-      } finally {
-        this.uninstall();
-      }
-    };
 
-    self.mockDate = function(initialDate) {
+        self.setTimeout = function(fn, delay, params) {
-      mockDate.install(initialDate);
+            if (legacyIE()) {
-    };
+                if (arguments.length > 2) {
+                    throw new Error('IE < 9 cannot support extra params to setTimeout without a polyfill');
+                }
+                return timer.setTimeout(fn, delay);
+            }
+            return Function.prototype.apply.apply(timer.setTimeout, [global, arguments]);
+        };
 
-    self.setTimeout = function(fn, delay, params) {
+        self.setInterval = function(fn, delay, params) {
-      if (legacyIE()) {
+            if (legacyIE()) {
-        if (arguments.length > 2) {
+                if (arguments.length > 2) {
-          throw new Error('IE < 9 cannot support extra params to setTimeout without a polyfill');
+                    throw new Error('IE < 9 cannot support extra params to setInterval without a polyfill');
-        }
+                }
-        return timer.setTimeout(fn, delay);
+                return timer.setInterval(fn, delay);
-      }
+            }
-      return Function.prototype.apply.apply(timer.setTimeout, [global, arguments]);
+            return Function.prototype.apply.apply(timer.setInterval, [global, arguments]);
-    };
+        };
 
-    self.setInterval = function(fn, delay, params) {
+        self.clearTimeout = function(id) {
-      if (legacyIE()) {
+            return Function.prototype.call.apply(timer.clearTimeout, [global, id]);
-        if (arguments.length > 2) {
+        };
-          throw new Error('IE < 9 cannot support extra params to setInterval without a polyfill');
-        }
-        return timer.setInterval(fn, delay);
-      }
-      return Function.prototype.apply.apply(timer.setInterval, [global, arguments]);
-    };
 
-    self.clearTimeout = function(id) {
+        self.clearInterval = function(id) {
-      return Function.prototype.call.apply(timer.clearTimeout, [global, id]);
+            return Function.prototype.call.apply(timer.clearInterval, [global, id]);
-    };
+        };
 
-    self.clearInterval = function(id) {
+        self.tick = function(millis) {
-      return Function.prototype.call.apply(timer.clearInterval, [global, id]);
+            if (installed) {
-    };
+                mockDate.tick(millis);
+                delayedFunctionScheduler.tick(millis);
+            } else {
+                throw new Error('Mock clock is not installed, use jasmine.clock().install()');
+            }
+        };
 
-    self.tick = function(millis) {
+        return self;
-      if (installed) {
-        mockDate.tick(millis);
-        delayedFunctionScheduler.tick(millis);
-      } else {
-        throw new Error('Mock clock is not installed, use jasmine.clock().install()');
-      }
-    };
 
-    return self;
+        function originalTimingFunctionsIntact() {
-
+            return global.setTimeout === realTimingFunctions.setTimeout &&
-    function originalTimingFunctionsIntact() {
-      return global.setTimeout === realTimingFunctions.setTimeout &&
         global.clearTimeout === realTimingFunctions.clearTimeout &&
         global.setInterval === realTimingFunctions.setInterval &&
         global.clearInterval === realTimingFunctions.clearInterval;
+        }
+
+        function legacyIE() {
+            //if these methods are polyfilled, apply will be present
+            return !(realTimingFunctions.setTimeout || realTimingFunctions.setInterval).apply;
+        }
+
+        function replace(dest, source) {
+            for (const prop in source) {
+                dest[prop] = source[prop];
+            }
+        }
+
+        function setTimeout(fn, delay) {
+            return delayedFunctionScheduler.scheduleFunction(fn, delay, argSlice(arguments, 2));
+        }
+
+        function clearTimeout(id) {
+            return delayedFunctionScheduler.removeFunctionWithId(id);
+        }
+
+        function setInterval(fn, interval) {
+            return delayedFunctionScheduler.scheduleFunction(fn, interval, argSlice(arguments, 2), true);
+        }
+
+        function clearInterval(id) {
+            return delayedFunctionScheduler.removeFunctionWithId(id);
+        }
+
+        function argSlice(argsObj, n) {
+            return Array.prototype.slice.call(argsObj, n);
+        }
     }
 
-    function legacyIE() {
+    return Clock;
-      //if these methods are polyfilled, apply will be present
-      return !(realTimingFunctions.setTimeout || realTimingFunctions.setInterval).apply;
-    }
-
-    function replace(dest, source) {
-      for (const prop in source) {
-        dest[prop] = source[prop];
-      }
-    }
-
-    function setTimeout(fn, delay) {
-      return delayedFunctionScheduler.scheduleFunction(fn, delay, argSlice(arguments, 2));
-    }
-
-    function clearTimeout(id) {
-      return delayedFunctionScheduler.removeFunctionWithId(id);
-    }
-
-    function setInterval(fn, interval) {
-      return delayedFunctionScheduler.scheduleFunction(fn, interval, argSlice(arguments, 2), true);
-    }
-
-    function clearInterval(id) {
-      return delayedFunctionScheduler.removeFunctionWithId(id);
-    }
-
-    function argSlice(argsObj, n) {
-      return Array.prototype.slice.call(argsObj, n);
-    }
-  }
-
-  return Clock;
 }();
 
-
 j$.DelayedFunctionScheduler = function() {
-  function DelayedFunctionScheduler() {
+    function DelayedFunctionScheduler() {
-    const self = this;
+        const self = this;
-    const scheduledLookup = [];
+        const scheduledLookup = [];
-    const scheduledFunctions = {};
+        const scheduledFunctions = {};
-    let currentTime = 0;
+        let currentTime = 0;
-    let delayedFnCount = 0;
+        let delayedFnCount = 0;
 
-    self.tick = function(millis) {
+        self.tick = function(millis) {
-      millis = millis || 0;
+            millis = millis || 0;
-      const endTime = currentTime + millis;
+            const endTime = currentTime + millis;
 
-      runScheduledFunctions(endTime);
+            runScheduledFunctions(endTime);
-      currentTime = endTime;
+            currentTime = endTime;
-    };
+        };
 
-    self.scheduleFunction = function(funcToCall, millis, params, recurring, timeoutKey, runAtMillis) {
+        self.scheduleFunction = function(funcToCall, millis, params, recurring, timeoutKey, runAtMillis) {
-      let f;
+            let f;
-      if (typeof(funcToCall) === 'string') {
+            if (typeof(funcToCall) === 'string') {
-        /* jshint evil: true */
+                /* jshint evil: true */
-        f = function() { return eval(funcToCall); };
+                f = function() { return eval(funcToCall); };
-        /* jshint evil: false */
+                /* jshint evil: false */
-      } else {
+            } else {
-        f = funcToCall;
+                f = funcToCall;
-      }
+            }
 
-      millis = millis || 0;
+            millis = millis || 0;
-      timeoutKey = timeoutKey || ++delayedFnCount;
+            timeoutKey = timeoutKey || ++delayedFnCount;
-      runAtMillis = runAtMillis || (currentTime + millis);
+            runAtMillis = runAtMillis || (currentTime + millis);
 
-      const funcToSchedule = {
+            const funcToSchedule = {
         runAtMillis: runAtMillis,
         funcToCall: f,
         recurring: recurring,
         params: params,
         timeoutKey: timeoutKey,
         millis: millis,
-      };
+            };
 
-      if (runAtMillis in scheduledFunctions) {
+            if (runAtMillis in scheduledFunctions) {
-        scheduledFunctions[runAtMillis].push(funcToSchedule);
+                scheduledFunctions[runAtMillis].push(funcToSchedule);
-      } else {
+            } else {
-        scheduledFunctions[runAtMillis] = [funcToSchedule];
+                scheduledFunctions[runAtMillis] = [funcToSchedule];
-        scheduledLookup.push(runAtMillis);
+                scheduledLookup.push(runAtMillis);
-        scheduledLookup.sort(function(a, b) {
+                scheduledLookup.sort(function(a, b) {
-          return a - b;
+                    return a - b;
-        });
+                });
-      }
+            }
 
-      return timeoutKey;
+            return timeoutKey;
-    };
+        };
 
-    self.removeFunctionWithId = function(timeoutKey) {
+        self.removeFunctionWithId = function(timeoutKey) {
-      for (const runAtMillis in scheduledFunctions) {
+            for (const runAtMillis in scheduledFunctions) {
-        const funcs = scheduledFunctions[runAtMillis];
+                const funcs = scheduledFunctions[runAtMillis];
-        const i = indexOfFirstToPass(funcs, function(func) {
+                const i = indexOfFirstToPass(funcs, function(func) {
-          return func.timeoutKey === timeoutKey;
+                    return func.timeoutKey === timeoutKey;
-        });
+                });
 
-        if (i > -1) {
+                if (i > -1) {
-          if (funcs.length === 1) {
+                    if (funcs.length === 1) {
-            delete scheduledFunctions[runAtMillis];
+                        delete scheduledFunctions[runAtMillis];
-            deleteFromLookup(runAtMillis);
+                        deleteFromLookup(runAtMillis);
-          } else {
+                    } else {
-            funcs.splice(i, 1);
+                        funcs.splice(i, 1);
-          }
+                    }
 
-          // intervals get rescheduled when executed, so there's never more
+                    // intervals get rescheduled when executed, so there's never more
-          // than a single scheduled function with a given timeoutKey
+                    // than a single scheduled function with a given timeoutKey
-          break;
+                    break;
+                }
+            }
+        };
+
+        return self;
+
+        function indexOfFirstToPass(array, testFn) {
+            let index = -1;
+
+            for (let i = 0; i < array.length; ++i) {
+                if (testFn(array[i])) {
+                    index = i;
+                    break;
+                }
+            }
+
+            return index;
         }
-      }
-    };
 
-    return self;
+        function deleteFromLookup(key) {
+            const value = Number(key);
+            const i = indexOfFirstToPass(scheduledLookup, function(millis) {
+                return millis === value;
+            });
 
-    function indexOfFirstToPass(array, testFn) {
+            if (i > -1) {
-      let index = -1;
+                scheduledLookup.splice(i, 1);
-
+            }
-      for (let i = 0; i < array.length; ++i) {
-        if (testFn(array[i])) {
-          index = i;
-          break;
         }
-      }
 
-      return index;
+        function reschedule(scheduledFn) {
-    }
+            self.scheduleFunction(scheduledFn.funcToCall,
+                scheduledFn.millis,
+                scheduledFn.params,
+                true,
+                scheduledFn.timeoutKey,
+                scheduledFn.runAtMillis + scheduledFn.millis);
+        }
 
-    function deleteFromLookup(key) {
+        function forEachFunction(funcsToRun, callback) {
-      const value = Number(key);
+            for (let i = 0; i < funcsToRun.length; ++i) {
-      const i = indexOfFirstToPass(scheduledLookup, function(millis) {
+                callback(funcsToRun[i]);
-        return millis === value;
+            }
-      });
+        }
 
-      if (i > -1) {
+        function runScheduledFunctions(endTime) {
-        scheduledLookup.splice(i, 1);
+            if (scheduledLookup.length === 0 || scheduledLookup[0] > endTime) {
-      }
+                return;
-    }
+            }
 
-    function reschedule(scheduledFn) {
+            do {
-      self.scheduleFunction(scheduledFn.funcToCall,
+                currentTime = scheduledLookup.shift();
-        scheduledFn.millis,
-        scheduledFn.params,
-        true,
-        scheduledFn.timeoutKey,
-        scheduledFn.runAtMillis + scheduledFn.millis);
-    }
 
-    function forEachFunction(funcsToRun, callback) {
+                const funcsToRun = scheduledFunctions[currentTime];
-      for (let i = 0; i < funcsToRun.length; ++i) {
+                delete scheduledFunctions[currentTime];
-        callback(funcsToRun[i]);
-      }
-    }
 
-    function runScheduledFunctions(endTime) {
+                forEachFunction(funcsToRun, function(funcToRun) {
-      if (scheduledLookup.length === 0 || scheduledLookup[0] > endTime) {
+                    if (funcToRun.recurring) {
-        return;
+                        reschedule(funcToRun);
-      }
+                    }
+                });
 
-      do {
+                forEachFunction(funcsToRun, function(funcToRun) {
-        currentTime = scheduledLookup.shift();
+                    funcToRun.funcToCall.apply(null, funcToRun.params || []);
-
+                });
-        const funcsToRun = scheduledFunctions[currentTime];
+            } while (scheduledLookup.length > 0 &&
-        delete scheduledFunctions[currentTime];
+            // checking first if we're out of time prevents setTimeout(0)
-
+            // scheduled in a funcToRun from forcing an extra iteration
-        forEachFunction(funcsToRun, function(funcToRun) {
-          if (funcToRun.recurring) {
-            reschedule(funcToRun);
-          }
-        });
-
-        forEachFunction(funcsToRun, function(funcToRun) {
-          funcToRun.funcToCall.apply(null, funcToRun.params || []);
-        });
-      } while (scheduledLookup.length > 0 &&
-              // checking first if we're out of time prevents setTimeout(0)
-              // scheduled in a funcToRun from forcing an extra iteration
                  currentTime !== endTime &&
                  scheduledLookup[0] <= endTime);
+        }
     }
-  }
 
-  return DelayedFunctionScheduler;
+    return DelayedFunctionScheduler;
 }();
 
-
 j$.MockDate = function() {
-  function MockDate(global) {
+    function MockDate(global) {
-    const self = this;
+        const self = this;
-    let currentTime = 0;
+        let currentTime = 0;
 
-    if (!global || !global.Date) {
+        if (!global || !global.Date) {
-      self.install = function() {};
+            self.install = function() {};
-      self.tick = function() {};
+            self.tick = function() {};
-      self.uninstall = function() {};
+            self.uninstall = function() {};
-      return self;
+            return self;
-    }
-
-    const GlobalDate = global.Date;
-
-    self.install = function(mockDate) {
-      if (mockDate instanceof GlobalDate) {
-        currentTime = mockDate.getTime();
-      } else {
-        currentTime = new GlobalDate().getTime();
-      }
-
-      global.Date = FakeDate;
-    };
-
-    self.tick = function(millis) {
-      millis = millis || 0;
-      currentTime = currentTime + millis;
-    };
-
-    self.uninstall = function() {
-      currentTime = 0;
-      global.Date = GlobalDate;
-    };
-
-    createDateProperties();
-
-    return self;
-
-    function FakeDate() {
-      switch(arguments.length) {
-        case 0:
-          return new GlobalDate(currentTime);
-        case 1:
-          return new GlobalDate(arguments[0]);
-        case 2:
-          return new GlobalDate(arguments[0], arguments[1]);
-        case 3:
-          return new GlobalDate(arguments[0], arguments[1], arguments[2]);
-        case 4:
-          return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3]);
-        case 5:
-          return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
-                                arguments[4]);
-        case 6:
-          return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
-                                arguments[4], arguments[5]);
-        default:
-          return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
-                                arguments[4], arguments[5], arguments[6]);
-      }
-    }
-
-    function createDateProperties() {
-      FakeDate.prototype = GlobalDate.prototype;
-
-      FakeDate.now = function() {
-        if (GlobalDate.now) {
-          return currentTime;
-        } else {
-          throw new Error('Browser does not support Date.now()');
         }
-      };
 
-      FakeDate.toSource = GlobalDate.toSource;
+        const GlobalDate = global.Date;
-      FakeDate.toString = GlobalDate.toString;
+
-      FakeDate.parse = GlobalDate.parse;
+        self.install = function(mockDate) {
-      FakeDate.UTC = GlobalDate.UTC;
+            if (mockDate instanceof GlobalDate) {
+                currentTime = mockDate.getTime();
+            } else {
+                currentTime = new GlobalDate().getTime();
+            }
+
+            global.Date = FakeDate;
+        };
+
+        self.tick = function(millis) {
+            millis = millis || 0;
+            currentTime = currentTime + millis;
+        };
+
+        self.uninstall = function() {
+            currentTime = 0;
+            global.Date = GlobalDate;
+        };
+
+        createDateProperties();
+
+        return self;
+
+        function FakeDate() {
+            switch (arguments.length) {
+                case 0:
+                    return new GlobalDate(currentTime);
+                case 1:
+                    return new GlobalDate(arguments[0]);
+                case 2:
+                    return new GlobalDate(arguments[0], arguments[1]);
+                case 3:
+                    return new GlobalDate(arguments[0], arguments[1], arguments[2]);
+                case 4:
+                    return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3]);
+                case 5:
+                    return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
+                        arguments[4]);
+                case 6:
+                    return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
+                        arguments[4], arguments[5]);
+                default:
+                    return new GlobalDate(arguments[0], arguments[1], arguments[2], arguments[3],
+                        arguments[4], arguments[5], arguments[6]);
+            }
+        }
+
+        function createDateProperties() {
+            FakeDate.prototype = GlobalDate.prototype;
+
+            FakeDate.now = function() {
+                if (GlobalDate.now) {
+                    return currentTime;
+                } else {
+                    throw new Error('Browser does not support Date.now()');
+                }
+            };
+
+            FakeDate.toSource = GlobalDate.toSource;
+            FakeDate.toString = GlobalDate.toString;
+            FakeDate.parse = GlobalDate.parse;
+            FakeDate.UTC = GlobalDate.UTC;
+        }
     }
-	}
 
-  return MockDate;
+    return MockDate;
 }();
 
 const _clock = new j$.Clock(global, function() { return new j$.DelayedFunctionScheduler(); }, new j$.MockDate(global));
@@ -418,4 +415,3 @@ export function clock() {
     return _clock;
 }
 
-