diff --git a/deps/chakrashim/lib/chakra_shim.js b/deps/chakrashim/lib/chakra_shim.js
index aa21685977e..4883f4dac71 100644
--- a/deps/chakrashim/lib/chakra_shim.js
+++ b/deps/chakrashim/lib/chakra_shim.js
@@ -19,67 +19,68 @@
 // IN THE SOFTWARE.
 'use strict';
 
-// CHAKRA-TODO doesn't implement the debugger. So add a dummy 'Debug' on
+// CHAKRA-TODO doesn't implement the debugger. So add a dummy 'Debug' on
 // global object for now.
-Object.defineProperty(this, 'Debug',
+Object.defineProperty(this, 'Debug',
      { value: {}, enumerable: false, configurable: false, writable: false });
 
 (function() {
   // Save original builtIns
-  var Object_defineProperty = Object.defineProperty,
-      Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
-      Object_getOwnPropertyNames = Object.getOwnPropertyNames,
-      Object_keys = Object.keys,
-      Object_prototype_toString = Object.prototype.toString,
-      Map_keys = Map.prototype.keys,
-      Map_values = Map.prototype.values,
-      Map_entries = Map.prototype.entries,
-      Set_entries = Set.prototype.entries,
-      Set_values = Set.prototype.values;
+  var
+    Object_defineProperty = Object.defineProperty,
+    Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
+    Object_getOwnPropertyNames = Object.getOwnPropertyNames,
+    Object_keys = Object.keys,
+    Object_prototype_toString = Object.prototype.toString,
+    Map_keys = Map.prototype.keys,
+    Map_values = Map.prototype.values,
+    Map_entries = Map.prototype.entries,
+    Set_entries = Set.prototype.entries,
+    Set_values = Set.prototype.values;
 
   // Simulate V8 JavaScript stack trace API
-  function StackFrame(funcName, fileName, lineNumber, columnNumber) {
+  function StackFrame(funcName, fileName, lineNumber, columnNumber) {
     this.column = columnNumber;
     this.lineNumber = lineNumber;
     this.scriptName = fileName;
-    this.functionName = funcName;
+    this.functionName = funcName;
   }
 
-  StackFrame.prototype.getFunctionName = function() {
-    return this.functionName;
+  StackFrame.prototype.getFunctionName = function() {
+    return this.functionName;
   };
 
-  StackFrame.prototype.getFileName = function() {
-    return this.scriptName;
+  StackFrame.prototype.getFileName = function() {
+    return this.scriptName;
   };
 
-  StackFrame.prototype.getLineNumber = function() {
-    return this.lineNumber;
+  StackFrame.prototype.getLineNumber = function() {
+    return this.lineNumber;
   };
 
-  StackFrame.prototype.getColumnNumber = function() {
-    return this.column;
+  StackFrame.prototype.getColumnNumber = function() {
+    return this.column;
   };
 
   StackFrame.prototype.isEval = function() {
     // TODO
-    return false;
+    return false;
   };
 
-  StackFrame.prototype.toString = function() {
+  StackFrame.prototype.toString = function() {
     return (this.functionName || 'Anonymous function') + ' (' +
-      this.scriptName + ':' + this.lineNumber + ':' + this.column + ')';
+      this.scriptName + ':' + this.lineNumber + ':' + this.column + ')';
   };
 
-  function prepareStackTrace(error, stack) {
+  function prepareStackTrace(error, stack) {
     var stackString = (error.name ? error.name : 'Error') +
       ': ' + error.message;
 
-    for (var i = 0; i < stack.length; i++) {
-      stackString += '\n   at ' + stack[i].toString();
+    for (var i = 0; i < stack.length; i++) {
+      stackString += '\n   at ' + stack[i].toString();
     }
 
-    return stackString;
+    return stackString;
   }
 
   function parseStack(stack, skipDepth, startFunc) {
@@ -91,18 +92,18 @@ Object.defineProperty(this, 'Debug',
     var startName = skipDepth < 0 ? startFunc.name : undefined;
     skipDepth = Math.max(0, skipDepth);
 
-    for (var i = skipDepth; i < splittedStack.length; i++) {
+    for (var i = skipDepth; i < splittedStack.length; i++) {
       var parens = /\(/.exec(splittedStack[i]);
       var funcName = splittedStack[i].substr(6, parens.index - 7);
 
-      if (startName) {
-        if (funcName === startName) {
-          startName = undefined;
+      if (startName) {
+        if (funcName === startName) {
+          startName = undefined;
         }
-        continue;
+        continue;
       }
-      if (funcName === 'Anonymous function') {
-        funcName = null;
+      if (funcName === 'Anonymous function') {
+        funcName = null;
       }
 
       var location = splittedStack[i].substr(parens.index + 1,
@@ -114,247 +115,247 @@ Object.defineProperty(this, 'Debug',
 
       var colonPattern = /:[0-9]+/g;
       var firstColon = colonPattern.exec(location);
-      if (firstColon) {
+      if (firstColon) {
         fileName = location.substr(0, firstColon.index);
 
         var secondColon = colonPattern.exec(location);
-        if (secondColon) {
+        if (secondColon) {
           lineNumber = parseInt(location.substr(firstColon.index + 1,
               secondColon.index - firstColon.index - 1), 10);
           columnNumber = parseInt(location.substr(secondColon.index + 1,
-              location.length - secondColon.index), 10);
-        }
+              location.length - secondColon.index), 10);
+        }
       }
       errstack.push(
-          new StackFrame(funcName, fileName, lineNumber, columnNumber));
+          new StackFrame(funcName, fileName, lineNumber, columnNumber));
     }
-    return errstack;
+    return errstack;
   }
 
-  function findFuncDepth(func) {
-    try {
+  function findFuncDepth(func) {
+    try {
       var curr = captureStackTrace.caller;
       var limit = Error.stackTraceLimit;
       var skipDepth = 0;
-      while (curr) {
+      while (curr) {
         skipDepth++;
-        if (curr === func) {
-          return skipDepth;
+        if (curr === func) {
+          return skipDepth;
         }
-        if (skipDepth > limit) {
-          return 0;
+        if (skipDepth > limit) {
+          return 0;
         }
-        curr = curr.caller;
-      }
+        curr = curr.caller;
+      }
     } catch (e) {
       // Strict mode may throw on .caller. Will try to match by function name.
-      return -1;
+      return -1;
     }
 
-    return 0;
+    return 0;
   }
 
-  function captureStackTrace(err, func) {
+  function captureStackTrace(err, func) {
     var currentStack;
     try { throw new Error(); } catch (e) { currentStack = e.stack; }
     var isPrepared = false;
     var skipDepth = func ? findFuncDepth(func) : 0;
 
     var currentStackTrace;
-    function ensureStackTrace() {
-      if (!currentStackTrace) {
-        currentStackTrace = parseStack(currentStack, skipDepth, func);
+    function ensureStackTrace() {
+      if (!currentStackTrace) {
+        currentStackTrace = parseStack(currentStack, skipDepth, func);
       }
-      return currentStackTrace;
+      return currentStackTrace;
     }
 
-    Object_defineProperty(err, 'stack', {
-      get: function() {
-        if (isPrepared) {
-          return currentStack;
+    Object_defineProperty(err, 'stack', {
+      get: function() {
+        if (isPrepared) {
+          return currentStack;
         }
         var errstack = ensureStackTrace();
-        if (Error.prepareStackTrace) {
-          currentStack = Error.prepareStackTrace(err, errstack);
-        } else {
-          currentStack = prepareStackTrace(err, errstack);
+        if (Error.prepareStackTrace) {
+          currentStack = Error.prepareStackTrace(err, errstack);
+        } else {
+          currentStack = prepareStackTrace(err, errstack);
         }
         isPrepared = true;
-        return currentStack;
+        return currentStack;
       },
-      set: function(value) {
+      set: function(value) {
         currentStack = value;
-        isPrepared = true;
+        isPrepared = true;
       },
       configurable: true,
-      enumerable: false
+      enumerable: false
     });
 
-    return ensureStackTrace;
+    return ensureStackTrace;
   };
 
-  function patchErrorStack() {
-    Error.captureStackTrace = captureStackTrace;
+  function patchErrorStack() {
+    Error.captureStackTrace = captureStackTrace;
   }
 
   var mapIteratorProperty = 'MapIteratorIndicator';
-  function patchMapIterator() {
-    var originalMapMethods = [];
-    originalMapMethods.push(['entries', Map_entries]);
-    originalMapMethods.push(['values', Map_values]);
-    originalMapMethods.push(['keys', Map_keys]);
-
-    originalMapMethods.forEach(function(pair) {
-      Map.prototype[pair[0]] = function() {
-        var result = pair[1].apply(this);
-        Object_defineProperty(result, mapIteratorProperty,
-          { value: true, enumerable: false, writable: false });
-        return result;
-      };
-    });
+  function patchMapIterator() {
+    var originalMapMethods = [];
+    originalMapMethods.push(['entries', Map_entries]);
+    originalMapMethods.push(['values', Map_values]);
+    originalMapMethods.push(['keys', Map_keys]);
+
+    originalMapMethods.forEach(function(pair) {
+      Map.prototype[pair[0]] = function() {
+        var result = pair[1].apply(this);
+        Object_defineProperty(result, mapIteratorProperty,
+          { value: true, enumerable: false, writable: false });
+        return result;
+      };
+    });
   }
 
   var setIteratorProperty = 'SetIteratorIndicator';
-  function patchSetIterator() {
-    var originalSetMethods = [];
-    originalSetMethods.push(['entries', Set_entries]);
-    originalSetMethods.push(['values', Set_values]);
-
-    originalSetMethods.forEach(function(pair) {
-      Set.prototype[pair[0]] = function() {
-        var result = pair[1].apply(this);
-        Object_defineProperty(result, setIteratorProperty,
-          { value: true, enumerable: false, writable: false });
-        return result;
-      };
-    });
+  function patchSetIterator() {
+    var originalSetMethods = [];
+    originalSetMethods.push(['entries', Set_entries]);
+    originalSetMethods.push(['values', Set_values]);
+
+    originalSetMethods.forEach(function(pair) {
+      Set.prototype[pair[0]] = function() {
+        var result = pair[1].apply(this);
+        Object_defineProperty(result, setIteratorProperty,
+          { value: true, enumerable: false, writable: false });
+        return result;
+      };
+    });
   }
 
-  function patchUtils(utils) {
+  function patchUtils(utils) {
     var isUintRegex = /^(0|[1-9]\\d*)$/;
 
-    var isUint = function(value) {
+    var isUint = function(value) {
       var result = isUintRegex.test(value);
       isUintRegex.lastIndex = 0;
-      return result;
+      return result;
     };
-    utils.cloneObject = function(source, target) {
-      Object_getOwnPropertyNames(source).forEach(function(key) {
-        try {
+    utils.cloneObject = function(source, target) {
+      Object_getOwnPropertyNames(source).forEach(function(key) {
+        try {
           var desc = Object_getOwnPropertyDescriptor(source, key);
           if (desc.value === source) desc.value = target;
-          Object_defineProperty(target, key, desc);
+          Object_defineProperty(target, key, desc);
         } catch (e) {
           // Catch sealed properties errors
-        }
-      });
+        }
+      });
     };
-    utils.getPropertyNames = function(a) {
+    utils.getPropertyNames = function(a) {
       var names = [];
-      for (var propertyName in a) {
-        names.push(propertyName);
+      for (var propertyName in a) {
+        names.push(propertyName);
       }
-      return names;
+      return names;
     };
-    utils.getEnumerableNamedProperties = function(obj) {
+    utils.getEnumerableNamedProperties = function(obj) {
       var props = [];
-      for (var key in obj) {
+      for (var key in obj) {
         if (!isUint(key))
-          props.push(key);
+          props.push(key);
       }
-      return props;
+      return props;
     };
-    utils.getEnumerableIndexedProperties = function(obj) {
+    utils.getEnumerableIndexedProperties = function(obj) {
       var props = [];
-      for (var key in obj) {
+      for (var key in obj) {
         if (isUint(key))
-          props.push(key);
+          props.push(key);
       }
-      return props;
+      return props;
     };
-    utils.createEnumerationIterator = function(props) {
+    utils.createEnumerationIterator = function(props) {
       var i = 0;
-      return {
-        next: function() {
+      return {
+        next: function() {
           if (i === props.length)
             return { done: true };
-          return { value: props[i++] };
-        }
-      };
+          return { value: props[i++] };
+        }
+      };
     };
-    utils.createPropertyDescriptorsEnumerationIterator = function(props) {
+    utils.createPropertyDescriptorsEnumerationIterator = function(props) {
       var i = 0;
-      return {
-        next: function() {
+      return {
+        next: function() {
           if (i === props.length) return { done: true };
-          return { name: props[i++], enumerable: true };
-        }
-      };
+          return { name: props[i++], enumerable: true };
+        }
+      };
     };
-    utils.getNamedOwnKeys = function(obj) {
+    utils.getNamedOwnKeys = function(obj) {
       var props = [];
-      Object_keys(obj).forEach(function(item) {
+      Object_keys(obj).forEach(function(item) {
         if (!isUint(item))
-          props.push(item);
+          props.push(item);
       });
-      return props;
+      return props;
     };
-    utils.getIndexedOwnKeys = function(obj) {
+    utils.getIndexedOwnKeys = function(obj) {
       var props = [];
-      Object_keys(obj).forEach(function(item) {
+      Object_keys(obj).forEach(function(item) {
         if (isUint(item))
-          props.push(item);
+          props.push(item);
       });
-      return props;
+      return props;
+    };
+    utils.getStackTrace = function() {
+      return captureStackTrace({}, utils.getStackTrace)();
+    };
+    utils.isMapIterator = function(value) {
+      return value[mapIteratorProperty] == true;
     };
-    utils.getStackTrace = function() {
-      return captureStackTrace({}, utils.getStackTrace)();
+    utils.isSetIterator = function(value) {
+      return value[setIteratorProperty] == true;
     };
-    utils.isMapIterator = function(value) {
-      return value[mapIteratorProperty] == true;
+    function compareType(o, expectedType) {
+      return Object_prototype_toString.call(o) === '[object ' +
+            expectedType + ']';
     };
-    utils.isSetIterator = function(value) {
-      return value[setIteratorProperty] == true;
-    };
-    function compareType(o, expectedType) {
-      return Object_prototype_toString.call(o) === '[object ' +
-            expectedType + ']';
-    };
-    utils.isBooleanObject = function(obj) {
-      return compareType(obj, 'Boolean');
-    };
-    utils.isDate = function(obj) {
-      return compareType(obj, 'Date');
-    };
-    utils.isMap = function(obj) {
-      return compareType(obj, 'Map');
-    };
-    utils.isNativeError = function(obj) {
-      return compareType(obj, 'Error') ||
-        obj instanceof Error ||
-        obj instanceof EvalError ||
-        obj instanceof RangeError ||
-        obj instanceof ReferenceError ||
-        obj instanceof SyntaxError ||
-        obj instanceof TypeError ||
-        obj instanceof URIError;
-    };
-    utils.isPromise = function(obj) {
-      return compareType(obj, 'Object') && obj instanceof Promise;
-    };
-    utils.isRegExp = function(obj) {
-      return compareType(obj, 'RegExp');
-    };
-    utils.isSet = function(obj) {
-      return compareType(obj, 'Set');
-    };
-    utils.isStringObject = function(obj) {
-      return compareType(obj, 'String');
-    };
-    utils.isNumberObject = function(obj) {
-      return compareType(obj, 'Number');
-    };
-
+    utils.isBooleanObject = function(obj) {
+      return compareType(obj, 'Boolean');
+    };
+    utils.isDate = function(obj) {
+      return compareType(obj, 'Date');
+    };
+    utils.isMap = function(obj) {
+      return compareType(obj, 'Map');
+    };
+    utils.isNativeError = function(obj) {
+      return compareType(obj, 'Error') ||
+        obj instanceof Error ||
+        obj instanceof EvalError ||
+        obj instanceof RangeError ||
+        obj instanceof ReferenceError ||
+        obj instanceof SyntaxError ||
+        obj instanceof TypeError ||
+        obj instanceof URIError;
+    };
+    utils.isPromise = function(obj) {
+      return compareType(obj, 'Object') && obj instanceof Promise;
+    };
+    utils.isRegExp = function(obj) {
+      return compareType(obj, 'RegExp');
+    };
+    utils.isSet = function(obj) {
+      return compareType(obj, 'Set');
+    };
+    utils.isStringObject = function(obj) {
+      return compareType(obj, 'String');
+    };
+    utils.isNumberObject = function(obj) {
+      return compareType(obj, 'Number');
+    };
+
   }
 
   // patch console
@@ -367,5 +368,5 @@ Object.defineProperty(this, 'Debug',
   patchSetIterator();
 
   // this is the keepAlive object that we will put some utilities function on
-  patchUtils(this);
-});
+  patchUtils(this);
+});