/* A comment
*/

// A comment

declare type numOrString = string | number

// A comment

declare type numOrString = string | number

const scores: int[]

"hello world"

function identity(arg: T): T {
   return arg;
}

class B {}
class A extends B {}

console.log("Hi")

// Typescript even supports splitting namespaces across multiple files:
// Validation.ts
namespace Validation {
    export interface StringValidator {
        isAcceptable(s: string): boolean;
    }
}
// LettersOnlyValidator.ts
/// 
namespace Validation {
    const lettersRegexp = /^[A-Za-z]+$/;
    export class LettersOnlyValidator implements StringValidator {
        isAcceptable(s: string) {
            return lettersRegexp.test(s);
        }
    }
}

// https://www.typescriptlang.org/docs/handbook/mixins.html
class SmartObject implements Disposable, Activatable {
}
// Note: still need to do some runtime ops to make that work.

// https://www.typescriptlang.org/docs/handbook/interfaces.html
interface SquareConfig {
   color?: string;
   width?: number;
}

import { ZipCodeValidator } from "./ZipCodeValidator";
/// 
/// 
import moo = module('moo');
/// 

something;

class Person {}

const result = true

function identity(arg: T): T {
   return arg;
}

abstract class Animal {}
class Dog extends Animal

class Person {
  private _age = 2
  public get age() {
    return _age
  }
  protected year = 1990
}

class Person {
  static sayHi() {
    console.log("Hello world")
  }
}

enum Direction {
 Up,
 Down
}

// 0[bB][01]+n?
0b100110100000110011110010010

// (\.[0-9]+|[0-9]+\.[0-9]*|[0-9]+)([eE][-+]?[0-9]+)?
80766866.0

// 0[xX][0-9a-fA-F]+n?
0x4D06792

// 0[oO]?[0-7]+n?
0o464063622

set = new Set()
set.add("foo")

function o(f, g) {
   return function(x) {
       return f(g(x));
   }
}

const o = {p: 42, q: true};
const {p, q} = o;

function multiply(a, b = 1) {
 return a * b;
}

let i = 0
i++
i--

class Person {
 method1() {}
 method2() {}
}

function helloWorld() {console.log("hi")}

let times = 10
while (times) {times--}
console.log("done")

let i = true ? 1 : 0

var animal = "dog"
switch (animal) {
 case "dog": console.log("yay"); break;
 case "cat": console.log("oh"); break;
}

1 + 1

const lines = `one
two`

(() => console.log("hello world"))()

const six = 2 + 2 + 2

console.log("hello " + 2)

var name = "John"

"use strict";
"use asm";

function* fibonacci(limit) {
    let [prev, curr] = [0, 1];
    while (!limit || curr <= limit) {
        yield curr;
        [prev, curr] = [curr, prev + curr];
    }
}
// bounded by upper limit 10
for (let n of fibonacci(10)) {
    console.log(n);
}
// generator without an upper bound limit
for (let n of fibonacci()) {
    console.log(n);
    if (n > 10000) break;
}
// manually iterating
let fibGen = fibonacci();
console.log(fibGen.next().value); // 1
console.log(fibGen.next().value); // 1
console.log(fibGen.next().value); // 2
console.log(fibGen.next().value); // 3
console.log(fibGen.next().value); // 5
console.log(fibGen.next().value); // 8
// picks up from where you stopped
for (let n of fibGen) {
    console.log(n);
    if (n > 10000) break;
}

[2.0,1.1].map(Math.round)

try {
 undefinedFn()
} catch (err) {
 console.log(err)
}

const one = 1

class Person {
 constructor(name) {
   this._name = name
 }
}
new Person("Jane")

main:
console.log("pldb")

if (true)
 console.log("hi!")

"hello world".toString().substr(0, 1).length

// Can be implemented in ES6 using proxies:
"use strict";
if (typeof Proxy == "undefined") {
    throw new Error("This browser doesn't support Proxy");
}
let original = {
    "foo": "bar"
};
let proxy = new Proxy(original, {
    get(target, name, receiver) {
        let rv = Reflect.get(target, name, receiver);
        if (typeof rv === "string") {
            rv = rv.toUpperCase();
        }
        return rv;
      }
});
console.log(`original.foo = ${original.foo}`); // "original.foo = bar"
console.log(`proxy.foo = ${proxy.foo}`);       // "proxy.foo = BAR"

class Person {}
const person = new Person()
person.age = 50

{
 version: 3,
 file: 'min.js',
 names: ['bar', 'baz', 'n'],
 sources: ['one.js', 'two.js'],
 sourceRoot: 'http://example.com/www/js/',
 mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
};

var x = 5 & 1;

"a" + "b"; 1 + 2

const list = [1,2,3]

80766866

if (false)
  debugger

const addNumbers = (num1, num2) => num1 + num2
const add5 = num => addNumbers(10, num)

[1,2.1].map(Math.round)

1 + 1

async doSomething => await somethingElse()

1 + 1

console.log("Hello World".match(/\w/))

let x = 3;

export function myFunction() {
}

// A symbol is a unique and immutable primitive value, often used as a unique key for object properties
pldb = Symbol()