import defaultExport from "module-name";
import * as name from "module-name";
import { prop } from "module-name";
import { prop as alias } from "module-name";
import { export1 , export2 } from "module-name";
import { export3 , export2 as alias4 } from "module-name";
import defaultExport1, { export5 , export6 as alias2 } from "module-name";
import defaultExport2, * as name1 from "module-name";
import "module-name";

try {
/*
This
Is a multiline
comment!
//  <= it can contain singline comments!
*/
class Thing extends Object {
  constructor({propertyA: foo} = {}) {
    super();

    label: for (var i = 0;i<2;i++) {
      break label;
      continue;
    }

    const obj = {foo:"bar"};
    delete obj.foo;
    foo in obj

    this instanceof Thing

    do {
      console.log("Fun")
    } while(0)
    	console.log("keywords:", `as; async; await; break; case;
catch; class; const; continue; debugger;
default; delete; do; else; enum;
export; extends; finally; for;
from; function; get; if; implements;
import; in; instanceof; interface; let;
new; null; of; package; private;
protected; public; return; set; static;
super; switch; this; throw;
try; typeof; var; void; while;
with; yield;`)
      console.log("operators:", `- -- -=
+ ++ +=
< <= << <<=
> >= >> >>= >>> >>>=
= == === =>
! != !==
& && &=
| || |=
* ** *= **=
/ /= ~
^ ^= % %=
? ...`);
    console.log(/regex literal/);
    console.log("This is"+ "/, not a regex")
    3 >= 2 || 2 <= 4 && 3 === 3 && 2 == 2
    var a = 4;
    a--
    a -= 2
    a = a+ 1
    a++
    a += 2
    a< 3
    a<= 4
    a<< 2
    a <<= 3
    a> 3
    a>= 3
    a>> 3
    a>>= 3
    a>>> 3
    a>>>= 3
    a = !a
    a!= a
    a!==a
    a & 2
    a && a
    a &= 2
    a| 2
    a || a
    a|=2
    a * 2
    a*= 2
    a**=2
    a/ 2
    a/= 3
    ~a
    a=a^2
    a^= 3
    a% 3
    a%=3

    a ? a : a

    42
    3.14159
    4e10
    3.2E+6
    2.1e-10
    0b1101
    0o571
    0xcafe
    0xCAFE
    NaN
    Infinity

    null
    void 0
    undefined
  }

  add(...args) {
    if (args.length > 1) {
      return args.pop() + add(...args);
    } else {
      return args[0];
    }
  }

  get english_greeting() {
    return "hi";
  }

  subtract(...args) {
    switch (args.length) {
      case 0:
        return 0;
      case 1:
        return args[0];
      default:
        return args.shift - subtract(...args)
    }
  }

  pow(a, exponent = 1) {
    return [a ** exponent];
  }

  async ಠ_ಠ(){
    return async function* () {
      let hello = "hello";
      var world = 'world';
      const what = `${hello.toUpperCase()}
${world.toUpperCase()}?
`;
		throw new Error("Please don't call this function");
      // This may not work
      return yield await delete typeof void this in new class extends async function () {} {}
    }
  }
}

  Thing.prototype.Ƞȡ_҇ = Thing.prototype.ಠ_ಠ;
new Thing

const identity = a => a

const i = (a) => {return a}

const fals = function (){return false}
const tru = () => true
} catch (e) {
} finally {
}