// And the default values can be any expression!
var x = 0;
var incX = () => x++;
function blah(a=incX()) { return x; }

console.log(blah()); // 0
console.log(blah()); // 1

// And you can reference any previously declared parameter
let isWut = (a, b=a || 12) => b;

isWut(true); // true
isWut(''); // 12

let sum = (a, b, s=a+b) => s;
sum(10, 20); // 30

let fib = (n, s=n > 2 ? sum(fib(n-1), fib(n-2)) : 1) => s;

var Y = function(F) {
    return function(f) { 
        return f(f); 
    }(function(f) {
        return F(
            function(x) { return (f(f))(x); }
        );
    });
};

let f = (a=(() => wut(12))(), b=(function (x, ...[{ dis: { is: y } }]) {
    return x ? ami(y) : 3
})(true instanceof {
    [Symbol.hasInstance()](x) { return !!x }
}), { dis: { is: 'wat' } }) => false;

// Maybe it's only defined in the parameters?
function foo(a=eval('var x = 12; x'), b=x) {
    console.log(b);
}
foo(); // ReferenceError: x is not defined

// What about shadowing declarations?
var x = 17;
function foo(a=x, x=12) {
    console.log(a);
}

foo(); // ReferenceError: x is not defined
// !?

// But what about this:
function foo(a=this) {
    'use strict';
    return a;
}

'use sloppy';
foo(); // undefined? global object?

// And what about this:
function foo(a=(function() {
    let x = 12;
    with ({ x: 42 })
        return x;
    // with is a syntax error in strict mode
})) {
    'use strict';
    return a;
}

// Randomly switch my mind about my children
var thing = {
    [Symbol.hasInstance]() { return Math.random() > 0.5; }
};

4 instanceof thing; // true? false? Who knows!

const Even = {
    [Symbol.hasInstance](x) { return !(x % 2); }
};

4 instanceof Even; // true
5 instanceof Even; // false

I'll be honest: I have no idea why.

Spec:

1. If Type(C) is not Object, throw a TypeError exception.

2. Let instOfHandler be GetMethod(C, @@hasInstance).

3. If instOfHandler is not undefined, then

   1. Return ToBoolean(Call(instOfHandler, C, « O »)).

4. If IsCallable(C) is false, throw a TypeError exception.

5. Return ? OrdinaryHasInstance(C, O).

MaybeHandle<Object> Object::InstanceOf(Isolate* isolate, Handle<Object> object,
                                       Handle<Object> callable) {
  // The {callable} must be a receiver.
  if (!callable->IsJSReceiver()) {
    THROW_NEW_ERROR(isolate,
                    NewTypeError(MessageTemplate::kNonObjectInInstanceOfCheck),
                    Object);
  }

  // Lookup the @@hasInstance method on {callable}.
  Handle<Object> inst_of_handler;
  ASSIGN_RETURN_ON_EXCEPTION(
      isolate, inst_of_handler,
      JSReceiver::GetMethod(Handle<JSReceiver>::cast(callable),
                            isolate->factory()->has_instance_symbol()),
      Object);
  if (!inst_of_handler->IsUndefined(isolate)) {
    // Call the {inst_of_handler} on the {callable}.
    Handle<Object> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate, result,
        Execution::Call(isolate, inst_of_handler, callable, 1, &object),
        Object);
    return isolate->factory()->ToBoolean(result->BooleanValue());
  }

  // The {callable} must have a [[Call]] internal method.
  if (!callable->IsCallable()) {
    THROW_NEW_ERROR(
        isolate, NewTypeError(MessageTemplate::kNonCallableInInstanceOfCheck),
        Object);
  }

  // Fall back to OrdinaryHasInstance with {callable} and {object}.
  Handle<Object> result;
  ASSIGN_RETURN_ON_EXCEPTION(
      isolate, result,
      JSReceiver::OrdinaryHasInstance(isolate, callable, object), Object);
  return result;
}

¯\_(ツ)_/¯

function countedReplace(pattern, count) {
    return {
        pattern, count,
        [Symbol.replace](subj, rep) {
            let c = this.count;
            // In This Function: Avoiding subclassing RegExp
            let p = new RegExp(this.pattern, this.pattern.flags.replace(/g|$/, 'g'));

            return subj.replace(p, $0 => c <= 0 ? $0 : (c--, rep));
        }
    }
}

'foo bar baz quz qux'.replace(countedReplace(/\w+/, 2), 'wut');
// wut wut baz quz qux

// Never used anywhere, ever

¯\_(ツ)_/¯

// Maybe flipping it to false?
var foo = [0, 1, 2];
[-2, -1].concat(foo); // [-2, -1, 0, 1, 2]

foo[Symbol.isConcatSpreadable] = false;
[-2, -1].concat(foo); // [-2, -1, [0, 1, 2]]

¯\_(ツ)_/¯

¯\_(ツ)_/¯

// ...but generators do have a prototype
obj.meth.prototype; // undefined
arrow.prototype; // undefined
asy.prototype; // undefined
gen.prototype; // Generator
// wut?

// It can still be used, just like the regular Function constructor!
var GeneratorFunction = Object.getPrototypeOf(gen).constructor;
var gen = GeneratorFunction('let x = yield 4; return x;');
var g = gen();
console.log(g.next()); // { value: 4, done: false }
console.log(g.next(12)); // { value: 12, done: true }

// This also applies to async functions:
var AsyncFunction = Object.getPrototypeOf(asy).constructor;
var wut = AsyncFunction('return await 4')
wut().then(r => console.log(r)); // 4

(function () {
    yield 4; // SyntaxError: Unexpected number
})();

(function () {
    var x = yield; // ReferenceError: yield is not defined
    return x;
})();

// Can be used to determine if you were `new`ed:
function foo() {
    console.log(new.target);
}

foo(); // undefined
new foo(); // foo

// super is attached at *object creation time*, so the following will not work
//as you expect:
var riddle =
    wut() {
        console.log(super.x); // Object.getPrototypeOf(riddle).x === undefined
    }
};
Object.assign(child, riddle);

foo.whatsX(); // 4
foo.whatsX.call({ x: 12 }); // 4

var wut = foo.whatsX.bind({ x: 13 });
wut(); // 4

// win

// Extending null has a special meaning, similar to Object.create(null)
class Regular {}
Object.getPrototypeOf(Regular.prototype); // Object.prototype

class Foo extends null {}
Object.getPrototypeOf(Regular.prototype); // null

// ...but leads to funky shit
new Foo; // TypeError: super is not a constructor

class Bar extends null { constructor() {} }
new Bar; // ReferenceError: this is not defined
// wut?

// Open question: How do we properly implement Foo or Bar?

// Now tell me, what does this do (hint: not a syntax error)?
foo: {
    console.log(1);
    break foo;
    console.log(2);
}

// What about this?
foo: function foo() {
    foo: {
        console.log(1);
        break foo;
        console.log(2);
    }
}

foo: try { throw 'wut'; }
catch (e) {
    console.log(1);
    break foo;
    console.log(2);
}

console.log(0);
<!-- console.log('wtf is this!?')
console.log(1);
--> console.log('i will not run!');
console.log(2);

<!--
console.log('wat');
--> <b>wat</b>