Strict mode

//     
"use strict";
var v = "Hi!  I'm a strict mode script!";

function strict() {
  // - strict mode 
  "use strict";
  function nested() {
    return "And so am I!";
  }
  return "Hi!  I'm a strict mode function!  " + nested();
}
function notStrict() {
  return "I'm not strict.";
}

function strict() {
  //   
}
export default strict;

"use strict";
//   mistypedVariable   
mistypedVaraible = 17; //     ReferenceError  

"use strict";

//     
var undefined = 5; // TypeError 
var Infinity = 5; // TypeError 

//     
var obj1 = {};
Object.defineProperty(obj1, "x", { value: 42, writable: false });
obj1.x = 9; // TypeError 

// getter-only  
var obj2 = {
  get x() {
    return 17;
  },
};
obj2.x = 5; // TypeError 

//      
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = "ohai"; // TypeError 

"use strict";
delete Object.prototype; // TypeError 

"use strict";
var o = { p: 1, p: 2 }; // !!!  

function sum(a, a, c) {
  // !!!  
  "use strict";
  return a + b + c; //    
}

var a = 0o10; // ES6: 8

"use strict";
var sum =
  015 + // !!!  
  197 +
  142;

(function () {
  "use strict";

  false.true = ""; // TypeError
  (14).sailing = "home"; // TypeError
  "with".you = "far away"; // TypeError
})();

"use strict";
var x = 17;
with (obj) {
  // !!!  
  //  ,  var x   ,
  // obj.x   ?
  //        ,
  //     .
  x;
}

var x = 17;
var evalX = eval("'use strict'; var x = 42; x");
console.assert(x === 17);
console.assert(evalX === 42);

function strict1(str) {
  "use strict";
  return eval(str); // str    
}
function strict2(f, str) {
  "use strict";
  return f(str); // eval(...)  :
  // str     
}
function nonstrict(str) {
  return eval(str); // str     
}

strict1("' !'");
strict1("'use strict'; ' !'");
strict2(eval, "' .'");
strict2(eval, "'use strict'; ' !'");
nonstrict("' .'");
nonstrict("'use strict'; ' !'");

"use strict";

var x;
delete x; // !!!  

eval("var y; delete y;"); // !!! syntax error

"use strict";
eval = 17;
arguments++;
++eval;
var obj = { set p(arguments) {} };
var eval;
try {
} catch (arguments) {}
function x(eval) {}
function arguments() {}
var y = function eval() {};
var f = new Function("arguments", "'use strict'; return 17;");

function f(a) {
  "use strict";
  a = 42;
  return [a, arguments[0]];
}
var pair = f(17);
console.assert(pair[0] === 42);
console.assert(pair[1] === 17);

"use strict";
var f = function () {
  return arguments.callee;
};
f(); // TypeError

"use strict";
function fun() {
  return this;
}
console.assert(fun() === undefined);
console.assert(fun.call(2) === 2);
console.assert(fun.apply(null) === null);
console.assert(fun.call(undefined) === undefined);
console.assert(fun.bind(true)() === true);

function restricted() {
  "use strict";
  restricted.caller; // throws a TypeError
  restricted.arguments; // throws a TypeError
}
function privilegedInvoker() {
  return restricted();
}
privilegedInvoker();

"use strict";
function fun(a, b) {
  "use strict";
  var v = 12;
  return arguments.caller; //TypeError  .
}
fun(1, 2); // doesn't expose v (or a or b)

function package(protected) {
  // !!!
  "use strict";
  var implements; // !!!

  // !!!
  interface: while (true) {
    break interface; // !!!
  }

  function private() {} // !!!
}
function fun(static) {
  "use strict";
} // !!!

"use strict";
if (true) {
  function f() {} // !!! syntax error
  f();
}

for (var i = 0; i < 5; i++) {
  function f2() {} // !!! syntax error
  f2();
}

function baz() {
  // kosher
  function eit() {} // also kosher
}