// single-line comment

/*
Comment with
multiple lines
*/

true
false

1.141
-123

17n
-49n

'abc'
"abc"
`String with interpolated values: ${256} and ${true}`

assert.equal(7 + 1, 8);

// Printing a value to standard out (another method call)
console.log('Hello!');

// Printing error information to standard error
console.error('Something went wrong!');

// Operators for booleans
assert.equal(true && false, false); // And
assert.equal(true || false, true); // Or

// Operators for numbers
assert.equal(3 + 4, 7);
assert.equal(5 - 1, 4);
assert.equal(3 * 4, 12);
assert.equal(10 / 4, 2.5);

// Operators for bigints
assert.equal(3n + 4n, 7n);
assert.equal(5n - 1n, 4n);
assert.equal(3n * 4n, 12n);
assert.equal(10n / 4n, 2n);

// Operators for strings
assert.equal('a' + 'b', 'ab');
assert.equal('I see ' + 3 + ' monkeys', 'I see 3 monkeys');

// Comparison operators
assert.equal(3 < 4, true);
assert.equal(3 <= 4, true);
assert.equal('abc' === 'abc', true);
assert.equal('abc' !== 'def', true);

// Declaring and initializing x (immutable binding):
const x = 8;

// Would cause a TypeError:
// x = 9;

// Declaring y (mutable binding):
let y;

// We can assign a different value to y:
y = 3 * 5;

// Declaring and initializing z:
let z = 3 * 5;

// add1() has the parameters a and b
function add1(a, b) {
  return a + b;
}
// Calling function add1()
assert.equal(add1(5, 2), 7);

const add2 = (a, b) => { return a + b };
// Calling function add2()
assert.equal(add2(5, 2), 7);

// Equivalent to add2:
const add3 = (a, b) => a + b;

// An arrow function whose body is a code block
(a, b) => { return a + b }

// An arrow function whose body is an expression
(a, b) => a + b

// Creating a plain object via an object literal
const obj = {
  first: 'Jane', // property
  last: 'Doe', // property
  getFullName() { // property (method)
    return this.first + ' ' + this.last;
  },
};

// Getting a property value
assert.equal(obj.first, 'Jane');
// Setting a property value
obj.first = 'Janey';

// Calling the method
assert.equal(obj.getFullName(), 'Janey Doe');

// Creating an Array via an Array literal
const arr = ['a', 'b', 'c'];
assert.equal(arr.length, 3);

// Getting an Array element
assert.equal(arr[1], 'b');
// Setting an Array element
arr[1] = 'β';

// Adding an element to an Array:
arr.push('d');

assert.deepEqual(
  arr, ['a', 'β', 'c', 'd']);

if (x < 0) {
  x = -x;
}

const arr = ['a', 'b'];
for (const element of arr) {
  console.log(element);
}
// Output:
// 'a'
// 'b'

export function isTextFilePath(filePath) {
  return filePath.endsWith('.txt');
}

// Import whole module as namespace object `path`
import * as path from 'path';
// Import a single export of module file-tools.mjs
import {isTextFilePath} from './file-tools.mjs';

class Person {
  constructor(name) {
    this.name = name;
  }
  describe() {
    return `Person named ${this.name}`;
  }
  static logNames(persons) {
    for (const person of persons) {
      console.log(person.name);
    }
  }
}

class Employee extends Person {
  constructor(name, title) {
    super(name);
    this.title = title;
  }
  describe() {
    return super.describe() +
      ` (${this.title})`;
  }
}

const jane = new Employee('Jane', 'CTO');
assert.equal(
  jane.describe(),
  'Person named Jane (CTO)');

function throwsException() {
  throw new Error('Problem!');
}

function catchesException() {
  try {
    throwsException();
  } catch (err) {
    assert.ok(err instanceof Error);
    assert.equal(err.message, 'Problem!');
  }
}

const if = 123;
  // SyntaxError: Unexpected token if

> const obj = { if: 123 };
> obj.if
123

arr.map((_x, i) => i)

class ValueWrapper {
  constructor(value) {
    this._value = value;
  }
}

const x = 123;
func();

while (false) {
  // ···
} // no semicolon

function func() {
  // ···
} // no semicolon

// Function declaration followed by empty statement:
function func() {
  // ···
};

const ε = 0.0001;
const строка = '';
let _tmp = 0;
const $foo2 = true;

let myStr;
if (myBool) {
  myStr = 'Yes';
} else {
  myStr = 'No';
}

function twice(x) {
  return x + x;
}

let myStr = (myBool ? 'Yes' : 'No');

> 'ab' + 'cd'
'abcd'
> Number('123')
123
> true || false
true

function f() {
  console.log(bar()); // bar() is expression
  bar(); // bar(); is (expression) statement  
}

function id(x) {
  return x;
}

const id = function me(x) {
  return x;
};

const obj = {};

{
}

(function (x) { console.log(x) })('abc');

// Output:
// 'abc'

const x = 3;
someFunction('abc');
i++;

function foo() {
  // ···
}
if (y > 0) {
  // ···
}

const func = () => {}; // semicolon!

while (condition)
  statement

while (a > 0) a--;

while (a > 0) {
  a--;
}

while (processNextItem() > 0);

while (processNextItem() > 0) {}

return
{
  first: 'jane'
};

return;
{
  first: 'jane';
}
;

a = b + c
(d + e).print()

a = b + c(d + e).print();

a = b
/hi/g.exec(c).map(d)

a = b / hi / g.exec(c).map(d);

someFunction()
['ul', 'ol'].map(x => x + x)

const propKey = ('ul','ol'); // comma operator
assert.equal(propKey, 'ol');

someFunction()[propKey].map(x => x + x);

'use strict';

function functionInStrictMode() {
  'use strict';
}

function sloppyFunc() {
  undeclaredVar1 = 123;
}
sloppyFunc();
// Created global variable `undeclaredVar1`:
assert.equal(undeclaredVar1, 123);

function strictFunc() {
  'use strict';
  undeclaredVar2 = 123;
}
assert.throws(
  () => strictFunc(),
  {
    name: 'ReferenceError',
    message: 'undeclaredVar2 is not defined',
  });

function strictFunc() {
  'use strict';
  {
    function foo() { return 123 }
  }
  return foo(); // ReferenceError
}
assert.throws(
  () => strictFunc(),
  {
    name: 'ReferenceError',
    message: 'foo is not defined',
  });

function sloppyFunc() {
  {
    function foo() { return 123 }
  }
  return foo(); // works
}
assert.equal(sloppyFunc(), 123);

function strictFunc() {
  'use strict';
  true.prop = 1; // TypeError
}
assert.throws(
  () => strictFunc(),
  {
    name: 'TypeError',
    message: "Cannot create property 'prop' on boolean 'true'",
  });

function sloppyFunc() {
  true.prop = 1; // fails silently
  return true.prop;
}
assert.equal(sloppyFunc(), undefined);