From 7d624ef828c574f17bd8f24f2c1cb38c002270b7 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sun, 18 Apr 2021 06:28:56 -0300
Subject: [PATCH 01/71] typo it's

---
 6-data-storage/03-indexeddb/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index a4fb78c1e..6bd347657 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -50,7 +50,7 @@ Unlike server-side databases, IndexedDB is client-side, the data is stored in th
 
 If the local database version is less than specified in `open`, then a special event `upgradeneeded` is triggered, and we can compare versions and upgrade data structures as needed.
 
-The `upgradeneeded` event also triggers when the database doesn't yet exist (technically, it's version is `0`), so we can perform the initialization.
+The `upgradeneeded` event also triggers when the database doesn't yet exist (technically, its version is `0`), so we can perform the initialization.
 
 Let's say we published the first version of our app.
 

From 47b1ca8df82a83a7ea7739df29d0d4d10ac84792 Mon Sep 17 00:00:00 2001
From: Bora Lee <learnerbr@gmail.com>
Date: Wed, 21 Apr 2021 12:51:22 +0900
Subject: [PATCH 02/71] Fix grammar and wrong information

---
 2-ui/4-forms-controls/2-focus-blur/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/4-forms-controls/2-focus-blur/article.md b/2-ui/4-forms-controls/2-focus-blur/article.md
index d4348d25b..b866a5e2b 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -104,7 +104,7 @@ The best recipe is to be careful when using these events. If we want to track us
 ```
 ## Allow focusing on any element: tabindex
 
-By default many elements do not support focusing.
+By default, many elements do not support focusing.
 
 The list varies a bit between browsers, but one thing is always correct: `focus/blur` support is guaranteed for elements that a visitor can interact with: `<button>`, `<input>`, `<select>`, `<a>` and so on.
 
@@ -118,7 +118,7 @@ That is: if we have two elements, the first has `tabindex="1"`, and the second h
 
 The switch order is: elements with `tabindex` from `1` and above go first (in the `tabindex` order), and then elements without `tabindex` (e.g. a regular `<input>`).
 
-Elements with matching `tabindex` are switched in the document source order (the default order).
+Elements without matching `tabindex` are switched in the document source order (the default order).
 
 There are two special values:
 

From 0ad314c6a0f69ab92bc295123bd7d797da8d5c7c Mon Sep 17 00:00:00 2001
From: Bora Lee <learnerbr@gmail.com>
Date: Thu, 22 Apr 2021 18:17:19 +0900
Subject: [PATCH 03/71] fix grammar

---
 2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
index 2cccea020..378bd1f54 100644
--- a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Make table cells editable on click.
 
-- On click -- the cell should became "editable" (textarea appears inside), we can change HTML. There should be no resize, all geometry should remain the same.
+- On click -- the cell should become "editable" (textarea appears inside), we can change HTML. There should be no resize, all geometry should remain the same.
 - Buttons OK and CANCEL appear below the cell to finish/cancel the editing.
 - Only one cell may be editable at a moment. While a `<td>` is in "edit mode", clicks on other cells are ignored.
 - The table may have many cells. Use event delegation.

From 62bc619ea3dc3e2f2a5686fe2120f9e224aeb255 Mon Sep 17 00:00:00 2001
From: Bora Lee <learnerbr@gmail.com>
Date: Thu, 22 Apr 2021 21:38:47 +0900
Subject: [PATCH 04/71] insert empty line

---
 2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
index fc48c21ff..644d814d9 100644
--- a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
@@ -9,4 +9,5 @@ Focus on the mouse. Then use arrow keys to move it:
 [demo src="solution"]
 
 P.S. Don't put event handlers anywhere except the `#mouse` element.
+
 P.P.S. Don't modify HTML/CSS, the approach should be generic and work with any element.

From 8292f9c70a067d5a76465caf79ee1226f36938c4 Mon Sep 17 00:00:00 2001
From: Jack Staples <jackstaplesjcrs@gmail.com>
Date: Sat, 24 Apr 2021 12:24:54 -0700
Subject: [PATCH 05/71] Update article.md

---
 1-js/08-prototypes/01-prototype-inheritance/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/08-prototypes/01-prototype-inheritance/article.md b/1-js/08-prototypes/01-prototype-inheritance/article.md
index cfec05689..02236af75 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/article.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/article.md
@@ -12,7 +12,7 @@ In JavaScript, objects have a special hidden property `[[Prototype]]` (as named
 
 ![prototype](object-prototype-empty.svg)
 
-When we read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, such thing is called "prototypal inheritance". And soon we'll study many examples of such inheritance, as well as cooler language features built upon it.
+When we read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, this is called "prototypal inheritance". And soon we'll study many examples of such inheritance, as well as cooler language features built upon it.
 
 The property `[[Prototype]]` is internal and hidden, but there are many ways to set it.
 

From 07b364df2140b2f49f0591c464ec84e46830fa40 Mon Sep 17 00:00:00 2001
From: Mike Mitchell <mikemitchell574@gmail.com>
Date: Thu, 29 Apr 2021 06:12:59 -0400
Subject: [PATCH 06/71] Replace preposition with verb

---
 1-js/05-data-types/01-primitives-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index 6c13acda6..552c3b3b6 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -39,7 +39,7 @@ Objects are "heavier" than primitives. They require additional resources to supp
 
 Here's the paradox faced by the creator of JavaScript:
 
-- There are many things one would want to do with a primitive like a string or a number. It would be great to access them as methods.
+- There are many things one would want to do with a primitive like a string or a number. It would be great to access them using methods.
 - Primitives must be as fast and lightweight as possible.
 
 The solution looks a little bit awkward, but here it is:

From 981e34b9d5359d7a6fe1d40dbd14c7ddb416d6f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Cervi=C3=B1o?= <jciv.public@gmail.com>
Date: Fri, 30 Apr 2021 12:18:57 -0400
Subject: [PATCH 07/71] Update article.md

---
 1-js/99-js-misc/04-reference-type/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/99-js-misc/04-reference-type/article.md b/1-js/99-js-misc/04-reference-type/article.md
index 227253436..1ec378059 100644
--- a/1-js/99-js-misc/04-reference-type/article.md
+++ b/1-js/99-js-misc/04-reference-type/article.md
@@ -4,7 +4,7 @@
 ```warn header="In-depth language feature"
 This article covers an advanced topic, to understand certain edge-cases better.
 
-It's not important. Many experienced developers live fine without knowing it. Read on if you're  want to know how things work under the hood.
+It's not important. Many experienced developers live fine without knowing it. Read on if you want to know how things work under the hood.
 ```
 
 A dynamically evaluated method call can lose `this`.

From 252cccf2aec6fe662556889f568eff4987c32e8a Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 7 May 2021 19:35:54 -0300
Subject: [PATCH 08/71] always strict

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9afe0fdaa..9b36d4584 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -69,7 +69,7 @@ There are core features, valid both for browser and server-side JavaScript.
 
 ### Always "use strict"
 
-Modules always `use strict`, by default. E.g. assigning to an undeclared variable will give an error.
+Modules always work in strict mode. E.g. assigning to an undeclared variable will give an error.
 
 ```html run
 <script type="module">

From 5f972c8bbe7ec0a9a3b963ab0d0984efec905350 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=83=E8=89=AF?= <yuanliang@dian.so>
Date: Tue, 11 May 2021 15:16:19 +0800
Subject: [PATCH 09/71] fix(classes): replace [[FunctionKind]] with
 [[IsClassConstructor]]

---
 1-js/09-classes/01-class/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
index 8d4731e1b..d19b9ca9a 100644
--- a/1-js/09-classes/01-class/article.md
+++ b/1-js/09-classes/01-class/article.md
@@ -144,7 +144,7 @@ The result of this definition is about the same. So, there are indeed reasons wh
 
 Still, there are important differences.
 
-1. First, a function created by `class` is labelled by a special internal property `[[FunctionKind]]:"classConstructor"`. So it's not entirely the same as creating it manually.
+1. First, a function created by `class` is labelled by a special internal property `[[IsClassConstructor]]: true`. So it's not entirely the same as creating it manually.
 
     The language checks for that property in a variety of places. For example, unlike a regular function, it must be called with `new`:
 

From 4f0641525f4f84babc9c1950259ee6825506dc20 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Thu, 13 May 2021 13:05:15 +0300
Subject: [PATCH 10/71] closes #2583

---
 6-data-storage/03-indexeddb/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index 665664b4d..19b5d7e9c 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -5,7 +5,7 @@ libs:
 
 # IndexedDB
 
-IndexedDB is a database that is built into browser, much more powerful than `localStorage`.
+IndexedDB is a database that is built into a browser, much more powerful than `localStorage`.
 
 - Stores almost any kind of values by keys, multiple key types.
 - Supports transactions for reliability.

From 74d14af1080a9e68de3a5296c7e87250c4fe21db Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Thu, 13 May 2021 13:13:12 +0300
Subject: [PATCH 11/71] minor fixes

---
 .../09-call-apply-decorators/article.md              | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index acba0965c..c5d785493 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -301,18 +301,18 @@ The only syntax difference between `call` and `apply` is that `call` expects a l
 So these two calls are almost equivalent:
 
 ```js
-func.call(context, ...args); // pass an array as list with spread syntax
-func.apply(context, args);   // is same as using call
+func.call(context, ...args);
+func.apply(context, args);
 ```
 
-There's only a subtle difference:
+They perform the same call of `func` with given context and arguments.
+
+There's only a subtle difference regarding `args`:
 
 - The spread syntax `...` allows to pass *iterable* `args` as the list to `call`.
 - The `apply` accepts only *array-like* `args`.
 
-So, where we expect an iterable, `call` works, and where we expect an array-like, `apply` works.
-
-And for objects that are both iterable and array-like, like a real array, we can use any of them, but `apply` will probably be faster, because most JavaScript engines internally optimize it better.
+...And for objects that are both iterable and array-like, such as a real array, we can use any of them, but `apply` will probably be faster, because most JavaScript engines internally optimize it better.
 
 Passing all arguments along with the context to another function is called *call forwarding*.
 

From 3bf8830f8e90179d2e6055e66d093b69e0fbc3bf Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@users.noreply.github.com>
Date: Thu, 13 May 2021 17:37:44 +0300
Subject: [PATCH 12/71] Update article.md

---
 1-js/05-data-types/04-array/article.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
index d722341bb..a86dead64 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -379,9 +379,7 @@ alert( arr[0] ); // undefined! no elements.
 alert( arr.length ); // length 2
 ```
 
-In the code above, `new Array(number)` has all elements `undefined`.
-
-To evade such surprises, we usually use square brackets, unless we really know what we're doing.
+To avoid such surprises, we usually use square brackets, unless we really know what we're doing.
 
 ## Multidimensional arrays
 

From 237920b71ea72a5ca308c626fc5e4ad1e2db43fb Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@users.noreply.github.com>
Date: Thu, 13 May 2021 17:40:00 +0300
Subject: [PATCH 13/71] Update article.md

---
 6-data-storage/02-localstorage/article.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/6-data-storage/02-localstorage/article.md b/6-data-storage/02-localstorage/article.md
index e2e2751db..d0483f3a3 100644
--- a/6-data-storage/02-localstorage/article.md
+++ b/6-data-storage/02-localstorage/article.md
@@ -127,17 +127,17 @@ Please note that both key and value must be strings.
 If were any other type, like a number, or an object, it gets converted to string automatically:
 
 ```js run
-sessionStorage.user = {name: "John"};
-alert(sessionStorage.user); // [object Object]
+localStorage.user = {name: "John"};
+alert(localStorage.user); // [object Object]
 ```
 
 We can use `JSON` to store objects though:
 
 ```js run
-sessionStorage.user = JSON.stringify({name: "John"});
+localStorage.user = JSON.stringify({name: "John"});
 
 // sometime later
-let user = JSON.parse( sessionStorage.user );
+let user = JSON.parse( localStorage.user );
 alert( user.name ); // John
 ```
 

From 33f1b11dc2e3ad14c5f4be44498eacf13736a1d8 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Thu, 13 May 2021 17:52:58 +0300
Subject: [PATCH 14/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9b36d4584..4f14ae155 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -57,7 +57,7 @@ Like this:
 
 The browser automatically fetches and evaluates the imported module (and its imports if needed), and then runs the script.
 
-```warn header="Modules work only via HTTP(s), not in local files"
+```warn header="Modules work only via HTTP(s), not locally"
 If you try to open a web-page locally, via `file://` protocol, you'll find that `import/export` directives don't work. Use a local web-server, such as [static-server](https://www.npmjs.com/package/static-server#getting-started) or use the "live server" capability of your editor, such as VS Code [Live Server Extension](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer) to test modules.
 ```
 

From 6ad89303b03f007136c9d606477c33161000f88e Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Thu, 13 May 2021 17:53:55 +0300
Subject: [PATCH 15/71] minor fixes

---
 6-data-storage/01-cookie/article.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/6-data-storage/01-cookie/article.md b/6-data-storage/01-cookie/article.md
index 9fc5f6955..ac2fda063 100644
--- a/6-data-storage/01-cookie/article.md
+++ b/6-data-storage/01-cookie/article.md
@@ -247,8 +247,11 @@ But anything more complicated, like a network request from another site or a for
 
 If that's fine for you, then adding `samesite=lax` will probably not break the user experience and add protection.
 
-Overall, `samesite` is a great option, but it has an important drawback:
-- `samesite` is ignored (not supported) by old browsers, year 2017 or so.
+Overall, `samesite` is a great option. 
+
+There's a drawback:
+
+- `samesite` is ignored (not supported) by very old browsers, year 2017 or so.
 
 **So if we solely rely on `samesite` to provide protection, then old browsers will be vulnerable.**
 

From fafab82e8a28eded845d91022fd12d2f00041e24 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 15 May 2021 00:16:49 -0300
Subject: [PATCH 16/71] typo

---
 .../15-regexp-catastrophic-backtracking/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
index 97f04a086..b6e1054fb 100644
--- a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
+++ b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
@@ -242,7 +242,7 @@ And in the original example `pattern:^(\w+\s?)*$` we may want to forbid backtrac
 
 Modern regular expression engines support possessive quantifiers for that. Regular quantifiers become possessive if we add `pattern:+` after them. That is, we use `pattern:\d++` instead of `pattern:\d+` to stop `pattern:+` from backtracking.
 
-Possessive quantifiers are in fact simpler than "regular" ones. They just match as many as they can, without any backtracking. The search process without bracktracking is simpler.
+Possessive quantifiers are in fact simpler than "regular" ones. They just match as many as they can, without any backtracking. The search process without backtracking is simpler.
 
 There are also so-called "atomic capturing groups" - a way to disable backtracking inside parentheses.
 

From 80956ed877518b0f270535b08d49608fc29cdde5 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 12:01:01 +0300
Subject: [PATCH 17/71] closes #2600

---
 1-js/02-first-steps/02-structure/article.md           |  4 ++--
 .../4-new-object-same-constructor/solution.md         | 11 ++++++++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index cf1dd53d2..7c6086d08 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -61,7 +61,7 @@ If you're curious to see a concrete example of such an error, check this code ou
 
 No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of the code: it shows `1` then `2`.
 
-Now, let's add an `alert` before the code and *not* finish it with a semicolon:
+Let's add an `alert` before the code and *not* finish it with a semicolon:
 
 ```js run no-beautify
 alert("There will be an error")
@@ -69,7 +69,7 @@ alert("There will be an error")
 [1, 2].forEach(alert)
 ```
 
-Now if we run the code, only the first `alert` is shown and then we have an error!
+Now if we run the code, only the first `alert` shows, and then we have an error!
 
 But everything is fine again if we add a semicolon after `alert`:
 ```js run
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index 0073e252e..372d50dd6 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -38,7 +38,12 @@ Why `user2.name` is `undefined`?
 Here's how `new user.constructor('Pete')` works:
 
 1. First, it looks for `constructor` in `user`. Nothing.
-2. Then it follows the prototype chain. The prototype of `user` is `User.prototype`, and it also has nothing.
-3. The value of `User.prototype` is a plain object `{}`, its prototype is `Object.prototype`. And there is `Object.prototype.constructor == Object`. So it is used.
+2. Then it follows the prototype chain. The prototype of `user` is `User.prototype`, and it also has no `constructor` (because we "forgot" to set it right!).
+3. Going further up the chain, `User.prototype` is a plain object, its prototype is the built-in `Object.prototype`. 
+4. Finally, for the built-in `Object.prototype`, there's a built-in `Object.prototype.constructor == Object`. So it is used.
 
-At the end, we have `let user2 = new Object('Pete')`. The built-in `Object` constructor ignores arguments, it always creates an empty object, similar to `let user2 = {}`, that's what we have in `user2` after all.
+Finally, at the end, we have `let user2 = new Object('Pete')`. 
+
+Probably, that's not what we want. We'd like to create `new User`, not `new Object`. That's the outcome of the missing `constructor`.
+
+(Just in case you're curious, the `new Object(...)` call converts its argument to an object. That's a theoretical thing, in practice no one calls `new Object` with a value, and generally we don't use `new Object` to make objects at all).
\ No newline at end of file

From 11e08904f9e22d8dd1422f0116aadcaa87ed2b98 Mon Sep 17 00:00:00 2001
From: Osvaldo Dias dos Santos <vadodsantos@yahoo.com>
Date: Sun, 16 May 2021 14:06:13 +0100
Subject: [PATCH 18/71] Fix typo.

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index d4092181e..96e9fa712 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -247,7 +247,7 @@ alert('12-34-56'.replaceAll("-", ":")) // 12:34:56
 
 ## regexp.exec(str)
 
-The method `regexp.exec(str)` method returns a match for `regexp` in the string `str`.  Unlike previous methods, it's called on a regexp, not on a string.
+The `regexp.exec(str)` method returns a match for `regexp` in the string `str`.  Unlike previous methods, it's called on a regexp, not on a string.
 
 It behaves differently depending on whether the regexp has flag `pattern:g`.
 

From 89183a0b4a008794861d504cd036c4c749ca78ac Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:04:28 +0300
Subject: [PATCH 19/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 34 +++++++++------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 7c6086d08..deef1399b 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -56,40 +56,36 @@ Errors which occur in such cases are quite hard to find and fix.
 If you're curious to see a concrete example of such an error, check this code out:
 
 ```js run
-[1, 2].forEach(alert)
+alert("Hello);
+
+[1, 2].forEach(alert);
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of the code: it shows `1` then `2`.
+No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
 
-Let's add an `alert` before the code and *not* finish it with a semicolon:
+Now let's remove the semicolon after the `alert`:
 
 ```js run no-beautify
-alert("There will be an error")
+alert("Hello")
 
-[1, 2].forEach(alert)
+[1, 2].forEach(alert);
 ```
 
-Now if we run the code, only the first `alert` shows, and then we have an error!
-
-But everything is fine again if we add a semicolon after `alert`:
-```js run
-alert("All fine now");
+The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
 
-[1, 2].forEach(alert)  
-```
+If we run this code, only the first `Hello` shows. There are no numbers any more.
 
-Now we have the "All fine now" message followed by `1` and `2`.
+The difference is because JavaScript does not assume a semicolon before square brackets `[...]`. And, as there's no semicolon, the code in the first example is treated as a single statement. 
 
-
-The error in the no-semicolon variant occurs because JavaScript does not assume a semicolon before square brackets `[...]`.
-
-So, because the semicolon is not auto-inserted, the code in the first example is treated as a single statement. Here's how the engine sees it:
+Here's how the engine sees it:
 
 ```js run no-beautify
-alert("There will be an error")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert)
 ```
 
-But it should be two separate statements, not one. Such a merging in this case is just wrong, hence the error. This can happen in other situations.
+Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
+
+This can happen in other situations also.
 ````
 
 We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.

From bad5236ed059cbc0903dbeb2c60f1a8d57f93b2e Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:05:30 +0300
Subject: [PATCH 20/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index deef1399b..095f04f22 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -56,7 +56,7 @@ Errors which occur in such cases are quite hard to find and fix.
 If you're curious to see a concrete example of such an error, check this code out:
 
 ```js run
-alert("Hello);
+alert("Hello");
 
 [1, 2].forEach(alert);
 ```

From 70049c3fdf546fe46e5b837e264e7003914de6db Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:06:55 +0300
Subject: [PATCH 21/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 095f04f22..a8472ed49 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -58,17 +58,17 @@ If you're curious to see a concrete example of such an error, check this code ou
 ```js run
 alert("Hello");
 
-[1, 2].forEach(alert);
+["World"].forEach(alert);
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
+No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `World`.
 
 Now let's remove the semicolon after the `alert`:
 
 ```js run no-beautify
 alert("Hello")
 
-[1, 2].forEach(alert);
+["World"].forEach(alert);
 ```
 
 The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
@@ -80,7 +80,7 @@ The difference is because JavaScript does not assume a semicolon before square b
 Here's how the engine sees it:
 
 ```js run no-beautify
-alert("Hello")[1, 2].forEach(alert)
+alert("Hello")["World"].forEach(alert)
 ```
 
 Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.

From 859fa9beddd24309dd46ba54149ea9eed29af5d9 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:08:21 +0300
Subject: [PATCH 22/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index a8472ed49..a5903ce9d 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -58,29 +58,29 @@ If you're curious to see a concrete example of such an error, check this code ou
 ```js run
 alert("Hello");
 
-["World"].forEach(alert);
+[1, 2].forEach(alert);
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `World`.
+No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
 
 Now let's remove the semicolon after the `alert`:
 
 ```js run no-beautify
 alert("Hello")
 
-["World"].forEach(alert);
+[1, 2].forEach(alert);
 ```
 
 The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
 
-If we run this code, only the first `Hello` shows. There are no numbers any more.
+If we run this code, only the first `Hello` shows (and then you may see the error, but it may also be hidden). There are no numbers any more.
 
 The difference is because JavaScript does not assume a semicolon before square brackets `[...]`. And, as there's no semicolon, the code in the first example is treated as a single statement. 
 
 Here's how the engine sees it:
 
 ```js run no-beautify
-alert("Hello")["World"].forEach(alert)
+alert("Hello")[1, 2].forEach(alert)
 ```
 
 Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.

From fb09afc0fd69a04424759233fa77f0f10ec5b73b Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:42:05 +0300
Subject: [PATCH 23/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index a5903ce9d..acefc3499 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -80,7 +80,7 @@ The difference is because JavaScript does not assume a semicolon before square b
 Here's how the engine sees it:
 
 ```js run no-beautify
-alert("Hello")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert);
 ```
 
 Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.

From f598b720ad464696e64cedf6824878a626c974a7 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:43:55 +0300
Subject: [PATCH 24/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index acefc3499..bc5730767 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -75,7 +75,7 @@ The difference compared to the code above is only one character: the semicolon a
 
 If we run this code, only the first `Hello` shows (and then you may see the error, but it may also be hidden). There are no numbers any more.
 
-The difference is because JavaScript does not assume a semicolon before square brackets `[...]`. And, as there's no semicolon, the code in the first example is treated as a single statement. 
+That's because JavaScript does not assume a semicolon before square brackets `[...]`. And, as there's no semicolon, the code in the first example is treated as a single statement. 
 
 Here's how the engine sees it:
 

From f84140232e2144692bb53ea21ff796c2ae2eee59 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:51:44 +0300
Subject: [PATCH 25/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index bc5730767..1547007ca 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -75,7 +75,7 @@ The difference compared to the code above is only one character: the semicolon a
 
 If we run this code, only the first `Hello` shows (and then you may see the error, but it may also be hidden). There are no numbers any more.
 
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. And, as there's no semicolon, the code in the first example is treated as a single statement. 
+That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the first example is treated as a single statement. 
 
 Here's how the engine sees it:
 

From 18a039473ac3931b56b3e3a56825adfb61a21d4b Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 16 May 2021 18:51:51 +0300
Subject: [PATCH 26/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 1547007ca..fb90b14ee 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -75,7 +75,7 @@ The difference compared to the code above is only one character: the semicolon a
 
 If we run this code, only the first `Hello` shows (and then you may see the error, but it may also be hidden). There are no numbers any more.
 
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the first example is treated as a single statement. 
+That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement. 
 
 Here's how the engine sees it:
 

From ac96edec3fe5afc6022b61a2c14c899b6c993dad Mon Sep 17 00:00:00 2001
From: Serhii Kulykov <iamkulykov@gmail.com>
Date: Mon, 17 May 2021 14:19:19 +0300
Subject: [PATCH 27/71] Remove mentions of :host-context

---
 .../6-shadow-dom-style/article.md             | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/8-web-components/6-shadow-dom-style/article.md b/8-web-components/6-shadow-dom-style/article.md
index 83a6962fa..98e246a7f 100644
--- a/8-web-components/6-shadow-dom-style/article.md
+++ b/8-web-components/6-shadow-dom-style/article.md
@@ -111,22 +111,7 @@ customElements.define('custom-dialog', class extends HTMLElement {
 
 Now the additional centering styles are only applied to the first dialog: `<custom-dialog centered>`.
 
-## :host-context(selector)
-
-Same as `:host`, but applied only if the shadow host or any of its ancestors in the outer document matches the `selector`.
-
-E.g. `:host-context(.dark-theme)` matches only if there's `dark-theme` class on `<custom-dialog>` on anywhere above it:
-
-```html
-<body class="dark-theme">
-  <!--
-    :host-context(.dark-theme) applies to custom-dialogs inside .dark-theme
-  -->
-  <custom-dialog>...</custom-dialog>
-</body>
-```
-
-To summarize, we can use `:host`-family of selectors to style the main element of the component, depending on the context. These styles (unless `!important`) can be overridden by the document.
+To summarize, we can use `:host`-family of selectors to style the main element of the component. These styles (unless `!important`) can be overridden by the document.
 
 ## Styling slotted content
 
@@ -317,7 +302,7 @@ Shadow DOM can include styles, such as `<style>` or `<link rel="stylesheet">`.
 
 Local styles can affect:
 - shadow tree,
-- shadow host with `:host`-family pseudoclasses,
+- shadow host with `:host` and `:host()` pseudoclasses,
 - slotted elements (coming from light DOM), `::slotted(selector)` allows to select  slotted elements themselves, but not their children.
 
 Document styles can affect:

From ae8248bb56c2a7f97cc4e620b45bb02586aff8bf Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 17 May 2021 17:29:29 +0300
Subject: [PATCH 28/71] minor fixes

---
 1-js/02-first-steps/02-structure/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index fb90b14ee..4f16a99de 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -73,9 +73,9 @@ alert("Hello")
 
 The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
 
-If we run this code, only the first `Hello` shows (and then you may see the error, but it may also be hidden). There are no numbers any more.
+If we run this code, only the first `Hello` shows (and there's an error, you may need to open the console to see it). There are no numbers any more.
 
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement. 
+That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement.
 
 Here's how the engine sees it:
 

From d2ae45deef66cf51d74cf70ecb23e63e10ef2a0f Mon Sep 17 00:00:00 2001
From: Dorin David <70648503+Dorin-David@users.noreply.github.com>
Date: Thu, 20 May 2021 09:08:28 +0200
Subject: [PATCH 29/71] Update article.md

Fixed typo
---
 .../04-private-protected-properties-methods/article.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/09-classes/04-private-protected-properties-methods/article.md b/1-js/09-classes/04-private-protected-properties-methods/article.md
index 2d47464c4..e26d0ec81 100644
--- a/1-js/09-classes/04-private-protected-properties-methods/article.md
+++ b/1-js/09-classes/04-private-protected-properties-methods/article.md
@@ -192,7 +192,7 @@ There's a finished JavaScript proposal, almost in the standard, that provides la
 
 Privates should start with `#`. They are only accessible from inside the class.
 
-For instance, here's a private `#waterLimit` property and the water-checking private method `#checkWater`:
+For instance, here's a private `#waterLimit` property and the water-checking private method `#fixWaterAmount`:
 
 ```js run
 class CoffeeMachine {

From ffa79a8692ffa43bae7e86e602f612c096c225ab Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:07:13 +0300
Subject: [PATCH 30/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 4f14ae155..9a8ef25ed 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -81,7 +81,7 @@ Modules always work in strict mode. E.g. assigning to an undeclared variable wil
 
 Each module has its own top-level scope. In other words, top-level variables and functions from a module are not seen in other scripts.
 
-In the example below, two scripts are imported, and `hello.js` tries to use `user` variable declared in `user.js`, and fails:
+In the example below, two scripts are imported, and `hello.js` tries to use `user` variable declared in `user.js`, and fails (you'll see the error in the console):
 
 [codetabs src="scopes" height="140" current="index.html"]
 

From a917f9c72d32b3cde03ea1e22c1b1412709e34a8 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:18:20 +0300
Subject: [PATCH 31/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9a8ef25ed..9be69aa1b 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -81,19 +81,24 @@ Modules always work in strict mode. E.g. assigning to an undeclared variable wil
 
 Each module has its own top-level scope. In other words, top-level variables and functions from a module are not seen in other scripts.
 
-In the example below, two scripts are imported, and `hello.js` tries to use `user` variable declared in `user.js`, and fails (you'll see the error in the console):
+In the example below, two scripts are imported, and `hello.js` tries to use `user` variable declared in `user.js`. It fails, because it's a separate module (you'll see the error in the console):
 
 [codetabs src="scopes" height="140" current="index.html"]
 
-Modules are expected to `export` what they want to be accessible from outside and `import` what they need.
+Modules should `export` what they want to be accessible from outside and `import` what they need.
 
-So we should import `user.js` into `hello.js` and get the required functionality from it instead of relying on global variables.
+- `user.js` should export the `user` variable.
+- `hello.js` should import it from `user.js` module.
+
+In other words, with modules we use import/export instead of relying on global variables.
 
 This is the correct variant:
 
 [codetabs src="scopes-working" height="140" current="hello.js"]
 
-In the browser, independent top-level scope also exists for each `<script type="module">`:
+In the browser, independent top-level scope also exists for each `<script type="module">`.
+
+Here are two scripts on the same page, both `type="module"`. They don't see each other's top-level variables:
 
 ```html run
 <script type="module">
@@ -108,7 +113,13 @@ In the browser, independent top-level scope also exists for each `<script type="
 </script>
 ```
 
-If we really need to make a window-level global variable, we can explicitly assign it to `window` and access as `window.user`. But that's an exception requiring a good reason.
+```smart
+In the case of a web browser, we can make a window-level global variable by explicitly assigning it to `window`, e.g. `window.user = "John"`. 
+
+Then all scripts will see it. 
+
+That said, making such global variables is frowned upon. Please try to avoid them.
+```
 
 ### A module code is evaluated only the first time when imported
 

From 94837c2e69e223a4c0feee3efc9a3ece4d9248b5 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:19:58 +0300
Subject: [PATCH 32/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9be69aa1b..1405ecc03 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -96,7 +96,7 @@ This is the correct variant:
 
 [codetabs src="scopes-working" height="140" current="hello.js"]
 
-In the browser, independent top-level scope also exists for each `<script type="module">`.
+In the browser, if we talk about HTML pages, independent top-level scope also exists for each `<script type="module">`.
 
 Here are two scripts on the same page, both `type="module"`. They don't see each other's top-level variables:
 

From 3e74537ea450fb033b3b0951e38f6331586e5efa Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:21:44 +0300
Subject: [PATCH 33/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 1405ecc03..d6006f8f2 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -114,9 +114,9 @@ Here are two scripts on the same page, both `type="module"`. They don't see each
 ```
 
 ```smart
-In the case of a web browser, we can make a window-level global variable by explicitly assigning it to `window`, e.g. `window.user = "John"`. 
+In the browser, we can make a variable window-level global by explicitly assigning it to a `window` property, e.g. `window.user = "John"`. 
 
-Then all scripts will see it. 
+Then all scripts will see it, both with `type="module"` and without it. 
 
 That said, making such global variables is frowned upon. Please try to avoid them.
 ```

From 006343a653cc7125d0871306d10f21f13b69839b Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:23:44 +0300
Subject: [PATCH 34/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index d6006f8f2..dfc247dac 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -123,9 +123,11 @@ That said, making such global variables is frowned upon. Please try to avoid the
 
 ### A module code is evaluated only the first time when imported
 
-If the same module is imported into multiple other places, its code is executed only the first time, then exports are given to all importers.
+If the same module is imported into multiple other modules, its code is executed only once, upon the first import. Then its exports are given to all further importers.
 
-That has important consequences. Let's look at them using examples:
+The one-time evaluation has important consequences, that we should be aware of. 
+
+Let's see a couple of examples.
 
 First, if executing a module code brings side-effects, like showing a message, then importing it multiple times will trigger it only once -- the first time:
 

From df45aed953e7d6575c36c3e66c2b40705f87acba Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:25:15 +0300
Subject: [PATCH 35/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index dfc247dac..45f5e85e6 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -146,7 +146,7 @@ import `./alert.js`; // Module is evaluated!
 import `./alert.js`; // (shows nothing)
 ```
 
-In practice, top-level module code is mostly used for initialization, creation of internal data structures, and if we want something to be reusable -- export it.
+Top-level module code should be used for initialization, creation of module-specific internal data structures. If we want to call something multiple times - we need to export it.
 
 Now, a more advanced example.
 

From 8871521f353f4e3d1a37c9cc29f3c1187cc82d8a Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:28:05 +0300
Subject: [PATCH 36/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 45f5e85e6..dba8431af 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -146,7 +146,7 @@ import `./alert.js`; // Module is evaluated!
 import `./alert.js`; // (shows nothing)
 ```
 
-Top-level module code should be used for initialization, creation of module-specific internal data structures. If we want to call something multiple times - we need to export it.
+There's a rule: top-level module code should be used for initialization, creation of module-specific internal data structures. If we need to make something callable multiple times - we should export it as a function, like we did with `sayHi` above.
 
 Now, a more advanced example.
 

From 1770074c5fe34160623016dd7b6f3799daa8caec Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:28:32 +0300
Subject: [PATCH 37/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index dba8431af..95bc98695 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -148,7 +148,7 @@ import `./alert.js`; // (shows nothing)
 
 There's a rule: top-level module code should be used for initialization, creation of module-specific internal data structures. If we need to make something callable multiple times - we should export it as a function, like we did with `sayHi` above.
 
-Now, a more advanced example.
+Now, let's consider a deeper example.
 
 Let's say, a module exports an object:
 

From 3dbe9d13fb5d778dafb1dde817bb8748efd8b7a0 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:29:27 +0300
Subject: [PATCH 38/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 95bc98695..87418fdf4 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -146,6 +146,8 @@ import `./alert.js`; // Module is evaluated!
 import `./alert.js`; // (shows nothing)
 ```
 
+The second import shows nothing, because the module has already been evaluated.
+
 There's a rule: top-level module code should be used for initialization, creation of module-specific internal data structures. If we need to make something callable multiple times - we should export it as a function, like we did with `sayHi` above.
 
 Now, let's consider a deeper example.

From 2fc7cb2d42eaf075a4a50e7baf750c2bea5a9ad4 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:33:37 +0300
Subject: [PATCH 39/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 87418fdf4..cece0ffb7 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -175,12 +175,14 @@ import {admin} from './admin.js';
 alert(admin.name); // Pete
 
 *!*
-// Both 1.js and 2.js imported the same object
+// Both 1.js and 2.js reference the same admin object
 // Changes made in 1.js are visible in 2.js
 */!*
 ```
 
-So, let's reiterate -- the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
+As you can see, when `1.js` changes the `name` property in the imported `admin`, then `2.js` can see the new `admin.name`.
+
+That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
 
 Such behavior allows us to *configure* modules on first import. We can setup its properties once, and then in further imports it's ready.
 

From 649a1598f5ae69187480c4542e93df598557837c Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:34:23 +0300
Subject: [PATCH 40/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index cece0ffb7..3292e230f 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -184,7 +184,9 @@ As you can see, when `1.js` changes the `name` property in the imported `admin`,
 
 That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
 
-Such behavior allows us to *configure* modules on first import. We can setup its properties once, and then in further imports it's ready.
+**Such behavior is great in practice, because it allows us to *configure* modules on first import.**
+
+We can setup its properties once, and then in further imports it's ready.
 
 For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `admin` object from outside:
 

From 62db4bbf708d4b108e42ec7ef72781adb2298570 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:35:04 +0300
Subject: [PATCH 41/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 3292e230f..9bdc0f306 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -184,7 +184,7 @@ As you can see, when `1.js` changes the `name` property in the imported `admin`,
 
 That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
 
-**Such behavior is great in practice, because it allows us to *configure* modules on first import.**
+**Such behavior is great, because it allows us to *configure* modules on first import.**
 
 We can setup its properties once, and then in further imports it's ready.
 

From 3288801422bf475da22a253d66a7f6bdd84c8999 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:35:11 +0300
Subject: [PATCH 42/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9bdc0f306..4c7b0464f 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -184,7 +184,7 @@ As you can see, when `1.js` changes the `name` property in the imported `admin`,
 
 That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
 
-**Such behavior is great, because it allows us to *configure* modules on first import.**
+**Such behavior is actually very convenient, because it allows us to *configure* modules on first import.**
 
 We can setup its properties once, and then in further imports it's ready.
 

From 6db496195e5072ac0d24d47645f7417b04512b19 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:35:52 +0300
Subject: [PATCH 43/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 4c7b0464f..8a1b9dfff 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -186,7 +186,7 @@ That's exactly because the module is executed only once. Exports are generated,
 
 **Such behavior is actually very convenient, because it allows us to *configure* modules on first import.**
 
-We can setup its properties once, and then in further imports it's ready.
+In other words, when the module code is evaluated (happens only the first time!), we can setup its properties once. And then in further imports it's ready.
 
 For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `admin` object from outside:
 

From 434354507c0d82d5852424c21902279a4bb5027f Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:44:05 +0300
Subject: [PATCH 44/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 30 ++++++++++++---------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 8a1b9dfff..93be20b0f 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -184,40 +184,44 @@ As you can see, when `1.js` changes the `name` property in the imported `admin`,
 
 That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
 
-**Such behavior is actually very convenient, because it allows us to *configure* modules on first import.**
+**Such behavior is actually very convenient, because it allows us to *configure* modules.**
 
-In other words, when the module code is evaluated (happens only the first time!), we can setup its properties once. And then in further imports it's ready.
+In other words, we can create variables with configuration and export them, so that the outer code can modify them.
 
-For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `admin` object from outside:
+For instance, the `admin.js` module may provide certain functionality (e.g. authentication), but expect the credentials to come into the `config` object from outside.
 
+First, we can export the `config` object (here it's initially empty, but that's not always the case):
 ```js
 // 📁 admin.js
-export let admin = { };
+export let config = { };
 
 export function sayHi() {
-  alert(`Ready to serve, ${admin.name}!`);
+  alert(`Ready to serve, ${config.user}!`);
 }
 ```
 
-In `init.js`, the first script of our app, we set `admin.name`. Then everyone will see it, including calls made from inside `admin.js` itself:
+Then in `init.js`, the first script of our app, we set `config.user`:
 
 ```js
 // 📁 init.js
-import {admin} from './admin.js';
-admin.name = "Pete";
+import {config} from './admin.js';
+config.user = "Pete";
 ```
 
-Another module can also see `admin.name`:
+...Now the module is configured. It's `config` property has the right user, and it can say hi to them (or provide authentication or whatever):
 
 ```js
-// 📁 other.js
-import {admin, sayHi} from './admin.js';
-
-alert(admin.name); // *!*Pete*/!*
+// 📁 another.js
+import {sayHi} from './admin.js';
 
 sayHi(); // Ready to serve, *!*Pete*/!*!
 ```
 
+Here's a classical pattern:
+1. A module exports some means of configuration.
+2. On the first import we initialize it.
+3. Further imports use the module.
+
 ### import.meta
 
 The object `import.meta` contains the information about the current module.

From 053cc055f4c4c9e6022275e72c2c1949312eab44 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:50:27 +0300
Subject: [PATCH 45/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 93be20b0f..932bfef88 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -186,7 +186,7 @@ That's exactly because the module is executed only once. Exports are generated,
 
 **Such behavior is actually very convenient, because it allows us to *configure* modules.**
 
-In other words, we can create variables with configuration and export them, so that the outer code can modify them.
+In other words, a module can provide a generic functionality that needs a setup. E.g. authentication needs credentials. Then we export a configuration object expecting the outer code to assign to it.
 
 For instance, the `admin.js` module may provide certain functionality (e.g. authentication), but expect the credentials to come into the `config` object from outside.
 

From 842f0e22a6d910e751bad45c49f61be98960f644 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:50:46 +0300
Subject: [PATCH 46/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 932bfef88..1531e48f3 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -186,7 +186,7 @@ That's exactly because the module is executed only once. Exports are generated,
 
 **Such behavior is actually very convenient, because it allows us to *configure* modules.**
 
-In other words, a module can provide a generic functionality that needs a setup. E.g. authentication needs credentials. Then we export a configuration object expecting the outer code to assign to it.
+In other words, a module can provide a generic functionality that needs a setup. E.g. authentication needs credentials. Then it can export a configuration object expecting the outer code to assign to it.
 
 For instance, the `admin.js` module may provide certain functionality (e.g. authentication), but expect the credentials to come into the `config` object from outside.
 

From 70bb2653e5032ba27b9c733bb87b0b1ff2e6e3e3 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:55:27 +0300
Subject: [PATCH 47/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 1531e48f3..2c9133f9b 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -188,9 +188,13 @@ That's exactly because the module is executed only once. Exports are generated,
 
 In other words, a module can provide a generic functionality that needs a setup. E.g. authentication needs credentials. Then it can export a configuration object expecting the outer code to assign to it.
 
-For instance, the `admin.js` module may provide certain functionality (e.g. authentication), but expect the credentials to come into the `config` object from outside.
+Here's a classical pattern:
+1. A module exports some means of configuration, e.g. a configuration object.
+2. On the first import we initialize it, write to its properties. The top-level application script may do that.
+3. Further imports use the module.
+
+For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `config` object from outside:
 
-First, we can export the `config` object (here it's initially empty, but that's not always the case):
 ```js
 // 📁 admin.js
 export let config = { };
@@ -200,6 +204,8 @@ export function sayHi() {
 }
 ```
 
+Here, `admin.js` exports the `config` object (initially empty, but that's not always the case).
+
 Then in `init.js`, the first script of our app, we set `config.user`:
 
 ```js
@@ -208,7 +214,9 @@ import {config} from './admin.js';
 config.user = "Pete";
 ```
 
-...Now the module is configured. It's `config` property has the right user, and it can say hi to them (or provide authentication or whatever):
+...Now the module is configured. 
+
+Further importers can call it, and it correctly shows the current user:
 
 ```js
 // 📁 another.js
@@ -217,10 +225,6 @@ import {sayHi} from './admin.js';
 sayHi(); // Ready to serve, *!*Pete*/!*!
 ```
 
-Here's a classical pattern:
-1. A module exports some means of configuration.
-2. On the first import we initialize it.
-3. Further imports use the module.
 
 ### import.meta
 

From fc3c0714db5e814bb4d59e4eefaa112b309e82dd Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:56:37 +0300
Subject: [PATCH 48/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 2c9133f9b..7e250faa9 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -188,7 +188,7 @@ That's exactly because the module is executed only once. Exports are generated,
 
 In other words, a module can provide a generic functionality that needs a setup. E.g. authentication needs credentials. Then it can export a configuration object expecting the outer code to assign to it.
 
-Here's a classical pattern:
+Here's the classical pattern:
 1. A module exports some means of configuration, e.g. a configuration object.
 2. On the first import we initialize it, write to its properties. The top-level application script may do that.
 3. Further imports use the module.

From 7a30a00f000d9b1320dd5f7659eac8c95bf69e07 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:57:17 +0300
Subject: [PATCH 49/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 7e250faa9..634dc68ce 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -191,7 +191,7 @@ In other words, a module can provide a generic functionality that needs a setup.
 Here's the classical pattern:
 1. A module exports some means of configuration, e.g. a configuration object.
 2. On the first import we initialize it, write to its properties. The top-level application script may do that.
-3. Further imports use the module.
+3. Further imports use the module (it's now configured).
 
 For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `config` object from outside:
 

From 6cfa8b46f69dd1ae57132e43c7baa9b0829f4ba5 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:57:39 +0300
Subject: [PATCH 50/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 634dc68ce..7e250faa9 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -191,7 +191,7 @@ In other words, a module can provide a generic functionality that needs a setup.
 Here's the classical pattern:
 1. A module exports some means of configuration, e.g. a configuration object.
 2. On the first import we initialize it, write to its properties. The top-level application script may do that.
-3. Further imports use the module (it's now configured).
+3. Further imports use the module.
 
 For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `config` object from outside:
 

From 649c75873adc3bb922f2af83f0a4e824b5e72d50 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:57:54 +0300
Subject: [PATCH 51/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 7e250faa9..fa0b8b9f6 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -193,7 +193,7 @@ Here's the classical pattern:
 2. On the first import we initialize it, write to its properties. The top-level application script may do that.
 3. Further imports use the module.
 
-For instance, the `admin.js` module may provide certain functionality, but expect the credentials to come into the `config` object from outside:
+For instance, the `admin.js` module may provide certain functionality (e.g. authentication), but expect the credentials to come into the `config` object from outside:
 
 ```js
 // 📁 admin.js

From f2636ee5126004d287bb1cdcecc8deeb8f4fff03 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:58:25 +0300
Subject: [PATCH 52/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index fa0b8b9f6..9e4bc940f 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -204,7 +204,7 @@ export function sayHi() {
 }
 ```
 
-Here, `admin.js` exports the `config` object (initially empty, but that's not always the case).
+Here, `admin.js` exports the `config` object (initially empty, but may have default properties too).
 
 Then in `init.js`, the first script of our app, we set `config.user`:
 

From 9ba208f6ecb31df7bee5c2a70b074734c4e1d40e Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 11:59:19 +0300
Subject: [PATCH 53/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 9e4bc940f..244df5fb4 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -206,7 +206,7 @@ export function sayHi() {
 
 Here, `admin.js` exports the `config` object (initially empty, but may have default properties too).
 
-Then in `init.js`, the first script of our app, we set `config.user`:
+Then in `init.js`, the first script of our app, we import `config` from it and set `config.user`:
 
 ```js
 // 📁 init.js
@@ -214,7 +214,7 @@ import {config} from './admin.js';
 config.user = "Pete";
 ```
 
-...Now the module is configured. 
+...Now the module `admin.js` is configured. 
 
 Further importers can call it, and it correctly shows the current user:
 

From cf33b67042d72df14e41f6688695ef833467f7f7 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 24 May 2021 12:00:52 +0300
Subject: [PATCH 54/71] minor fixes

---
 1-js/13-modules/01-modules-intro/article.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index 244df5fb4..7dc65a769 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -230,11 +230,12 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 The object `import.meta` contains the information about the current module.
 
-Its content depends on the environment. In the browser, it contains the url of the script, or a current webpage url if inside HTML:
+Its content depends on the environment. In the browser, it contains the URL of the script, or a current webpage URL if inside HTML:
 
 ```html run height=0
 <script type="module">
-  alert(import.meta.url); // script url (url of the html page for an inline script)
+  alert(import.meta.url); // script URL
+  // for an inline script - the URL of the current HTML-page
 </script>
 ```
 

From f8313dc936c5d6b594a3c0efff7c992cee3f46cc Mon Sep 17 00:00:00 2001
From: Ahmed Elaguab <elaguabahmed97@gmail.com>
Date: Fri, 28 May 2021 16:53:44 +0100
Subject: [PATCH 55/71] Update article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index d4092181e..f28145790 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -65,7 +65,7 @@ There are 3 differences from `match`:
 
 1. It returns an iterable object with matches instead of an array. We can make a regular array from it using `Array.from`.
 2. Every match is returned as an array with capturing groups (the same format as `str.match` without flag `pattern:g`).
-3. If there are no results, it returns not `null`, but an empty iterable object.
+3. If there are no results, it returns an empty iterable object instead of `null`.
 
 Usage example:
 

From 4c35f5998aec755a46d366dd38d0735f3eb10e3a Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 29 May 2021 18:40:18 -0300
Subject: [PATCH 56/71] "not required" vs "incorrect"

---
 1-js/02-first-steps/02-structure/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 4f16a99de..e81fd343d 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -46,7 +46,7 @@ alert(3 +
 + 2);
 ```
 
-The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so the semicolon is not required. And in this case that works as intended.
+The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so a semicolon there would be incorrect. And in this case, that works as intended.
 
 **But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
 

From c2d5f8e140fb74e70408b19daa22b3e40308a5ba Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 4 Jun 2021 07:06:50 -0300
Subject: [PATCH 57/71] easier to read

---
 2-ui/5-loading/01-onload-ondomcontentloaded/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/5-loading/01-onload-ondomcontentloaded/article.md b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
index 377e7703a..9cc9fc7c5 100644
--- a/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
+++ b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
@@ -45,7 +45,7 @@ For instance:
 <img id="img" src="https://en.js.cx/clipart/train.gif?speed=1&cache=0">
 ```
 
-In the example the `DOMContentLoaded` handler runs when the document is loaded, so it can see all the elements, including `<img>` below.
+In the example, the `DOMContentLoaded` handler runs when the document is loaded, so it can see all the elements, including `<img>` below.
 
 But it doesn't wait for the image to load. So `alert` shows zero sizes.
 

From 52cb88456599edb0a85a9e75bc6bdd76336207fb Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 7 Jun 2021 23:58:40 +0800
Subject: [PATCH 58/71] Update article.md

---
 9-regular-expressions/03-regexp-unicode/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/03-regexp-unicode/article.md b/9-regular-expressions/03-regexp-unicode/article.md
index 3e981c80a..712b6ecd0 100644
--- a/9-regular-expressions/03-regexp-unicode/article.md
+++ b/9-regular-expressions/03-regexp-unicode/article.md
@@ -107,7 +107,7 @@ Unicode supports many different properties, their full list would require a lot
 
 ### Example: hexadecimal numbers
 
-For instance, let's look for hexadecimal numbers, written as `xFF`, where `F` is a hex digit (0..1 or A..F).
+For instance, let's look for hexadecimal numbers, written as `xFF`, where `F` is a hex digit (0..9 or A..F).
 
 A hex digit can be denoted as `pattern:\p{Hex_Digit}`:
 

From 6a742c4a94d12be751d60d03146e735d30442dc0 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Tue, 8 Jun 2021 23:18:44 +0800
Subject: [PATCH 59/71] Update article.md

---
 1-js/02-first-steps/08-operators/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index 498870e42..decf5bcfc 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -63,8 +63,8 @@ In school maths, we write that as a<sup>b</sup>.
 For instance:
 
 ```js run
-alert( 2 ** 2 ); // 2² = 4  
-alert( 2 ** 3 ); // 2³ = 8 
+alert( 2 ** 2 ); // 2² = 4
+alert( 2 ** 3 ); // 2³ = 8
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 

From 581802dad33ba2152e34d3582208004ba5729f68 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Wed, 9 Jun 2021 07:08:21 +0300
Subject: [PATCH 60/71] minor fixes

---
 1-js/03-code-quality/01-debugging-chrome/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index 8c52735bf..cf90f5492 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -1,4 +1,4 @@
-# Debugging in Chrome
+# Debugging in the browser
 
 Before writing more complex code, let's talk about debugging.
 

From 68172cc9c4a7275d1614fbc4e9e7907760674045 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Thu, 10 Jun 2021 00:00:57 -0300
Subject: [PATCH 61/71] typo

---
 9-regular-expressions/07-regexp-escaping/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/07-regexp-escaping/article.md b/9-regular-expressions/07-regexp-escaping/article.md
index eed76791b..3a4640b49 100644
--- a/9-regular-expressions/07-regexp-escaping/article.md
+++ b/9-regular-expressions/07-regexp-escaping/article.md
@@ -65,7 +65,7 @@ The similar search in one of previous examples worked with `pattern:/\d\.\d/`, b
 
 The reason is that backslashes are "consumed" by a string. As we may recall, regular strings have their own special characters, such as `\n`, and a backslash is used for escaping.
 
-Here's how "\d\.\d" is preceived:
+Here's how "\d\.\d" is perceived:
 
 ```js run
 alert("\d\.\d"); // d.d

From 0e49461c92c0f6462bd8b2ccf66203455c7869d7 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Thu, 10 Jun 2021 00:02:47 -0300
Subject: [PATCH 62/71] typpo

---
 9-regular-expressions/11-regexp-groups/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/11-regexp-groups/article.md b/9-regular-expressions/11-regexp-groups/article.md
index e0ef00bd3..796e23f54 100644
--- a/9-regular-expressions/11-regexp-groups/article.md
+++ b/9-regular-expressions/11-regexp-groups/article.md
@@ -335,7 +335,7 @@ In the example below we only get the name `match:John` as a separate member of t
 let str = "Gogogo John!";
 
 *!*
-// ?: exludes 'go' from capturing
+// ?: excludes 'go' from capturing
 let regexp = /(?:go)+ (\w+)/i;
 */!*
 

From 964ba1530f961e751f092f743b4cf0a70d954fff Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 13 Jun 2021 10:46:23 +0300
Subject: [PATCH 63/71] function parameters vs arguments

---
 .../15-function-basics/article.md             | 53 ++++++++++++-------
 1 file changed, 33 insertions(+), 20 deletions(-)

diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index 0068bf194..ac6f1f47c 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -20,10 +20,10 @@ function showMessage() {
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above) and finally the code of the function, also named "the function body", between curly braces.
+The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above, we'll see examples later) and finally the code of the function, also named "the function body", between curly braces.
 
 ```js
-function name(parameters) {
+function name(parameter1, parameter2, ... parameterN) {
   ...body...
 }
 ```
@@ -137,26 +137,23 @@ It's a good practice to minimize the use of global variables. Modern code has fe
 
 ## Parameters
 
-We can pass arbitrary data to functions using parameters (also called *function arguments*) .
+We can pass arbitrary data to functions using parameters.
 
 In the example below, the function has two parameters: `from` and `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // arguments: from, text
+function showMessage(*!*from, text*/!*) { // parameters: from, text
   alert(from + ': ' + text);
 }
 
-*!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
-*/!*
+*!*showMessage('Ann', 'Hello!');*/!* // Ann: Hello! (*)
+*!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
 ```
 
 When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
 
 Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
 
-
 ```js run
 function showMessage(from, text) {
 
@@ -175,9 +172,21 @@ showMessage(from, "Hello"); // *Ann*: Hello
 alert( from ); // Ann
 ```
 
+When a value is passed as a function parameter, it's also called an *argument*.
+
+In other words, to put these terms straight:
+
+- A parameter is the variable listed inside the parentheses in the function declaration (it's a declaration time term)
+- An argument is the value that is passed to the function when it is called (it's a call time term).
+
+We declare functions listing their parameters, then call them passing arguments.
+
+In the example above, one might say: "the function `sayMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+
+
 ## Default values
 
-If a parameter is not provided, then its value becomes `undefined`.
+If a function is called, but an argument is not provided, then the corresponding value becomes `undefined`.
 
 For instance, the aforementioned function `showMessage(from, text)` can be called with a single argument:
 
@@ -185,9 +194,9 @@ For instance, the aforementioned function `showMessage(from, text)` can be calle
 showMessage("Ann");
 ```
 
-That's not an error. Such a call would output `"*Ann*: undefined"`. There's no `text`, so it's assumed that `text === undefined`.
+That's not an error. Such a call would output `"*Ann*: undefined"`. As the value for `text` isn't passed, it becomes `undefined`.
 
-If we want to use a "default" `text` in this case, then we can specify it after `=`:
+We can specify the so-called "default" (to use if omitted) value for a parameter in the function declaration, using `=`:
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -211,19 +220,23 @@ function showMessage(from, text = anotherFunction()) {
 ```smart header="Evaluation of default parameters"
 In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter.
 
-In the example above, `anotherFunction()` is called every time `showMessage()` is called without the `text` parameter.
+In the example above, `anotherFunction()` isn't called at all, if the `text` parameter is provided.
+
+On the other hand, it's independently called every time when `text` is missing.
 ```
 
 ### Alternative default parameters
 
-Sometimes it makes sense to set default values for parameters not in the function declaration, but at a later stage, during its execution.
+Sometimes it makes sense to assign default values for parameters not in the function declaration, but at a later stage.
 
-To check for an omitted parameter, we can compare it with `undefined`:
+We can check if the parameter is passed during the function execution, by comparing it with `undefined`:
 
 ```js run
 function showMessage(text) {
+  // ...
+
 *!*
-  if (text === undefined) {
+  if (text === undefined) { // if the parameter is missing
     text = 'empty message';
   }
 */!*
@@ -234,21 +247,21 @@ function showMessage(text) {
 showMessage(); // empty message
 ```
 
-...Or we could use the `||` operator:
+...Or we could use the `??` operator:
 
 ```js
-// if text parameter is omitted or "" is passed, set it to 'empty'
 function showMessage(text) {
+  // if text is undefined or otherwise falsy, set it to 'empty'
   text = text || 'empty';
   ...
 }
 ```
 
-Modern JavaScript engines support the [nullish coalescing operator](info:nullish-coalescing-operator) `??`, it's better when falsy values, such as `0`, are considered regular:
+Modern JavaScript engines support the [nullish coalescing operator](info:nullish-coalescing-operator) `??`, it's better when most falsy values, such as `0`, should be considered "normal":
 
 ```js run
-// if there's no "count" parameter, show "unknown"
 function showCount(count) {
+  // if count is undefined or null, show "unknown"
   alert(count ?? "unknown");
 }
 

From dcf4b5b4de67e6cc9b7da1799950389aada0ee09 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 13 Jun 2021 10:59:53 +0300
Subject: [PATCH 64/71] closes #2619

---
 1-js/04-object-basics/06-constructor-new/article.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 5f8709ae1..5c2bb9d74 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -64,10 +64,10 @@ Now if we want to create other users, we can call `new User("Ann")`, `new User("
 
 That's the main purpose of constructors -- to implement reusable object creation code.
 
-Let's note once again -- technically, any function can be used as a constructor. That is: any function can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
+Let's note once again -- technically, any function (except arrow functions, as they don't have `this`) can be used as a constructor. It can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
 
 ````smart header="new function() { ... }"
-If we have many lines of code all about creation of a single complex object, we can wrap them in constructor function, like this:
+If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this:
 
 ```js
 let user = new function() {
@@ -80,7 +80,7 @@ let user = new function() {
 };
 ```
 
-The constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
+This constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
 ````
 
 ## Constructor mode test: new.target

From bcf2e48443a0d1180393ba407a17af40fcf5d66b Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 13 Jun 2021 11:05:18 +0300
Subject: [PATCH 65/71] minor fixes

---
 1-js/01-getting-started/1-intro/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 49f821d18..f81e52822 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -26,7 +26,7 @@ Different engines have different "codenames". For example:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Chakra" for IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
+- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
 
 The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome and Opera.
 

From 617dfc7b04be03fde262507aca210f1805e61d34 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 13 Jun 2021 11:46:06 +0300
Subject: [PATCH 66/71] minor fixes

---
 1-js/02-first-steps/05-types/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 661760005..9fba1d8ad 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -64,7 +64,7 @@ Special numeric values formally belong to the "number" type. Of course they are
 
 We'll see more about working with numbers in the chapter <info:number>.
 
-## BigInt
+## BigInt [#bigint-type]
 
 In JavaScript, the "number" type cannot represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives. It's a technical limitation caused by their internal representation.
 

From e2d182364e6ef65cbcca2954853b40a3331abcd5 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 14 Jun 2021 01:48:06 +0300
Subject: [PATCH 67/71] minor fixes

---
 .../09-object-toprimitive/article.md          | 48 ++++++++++++++-----
 1 file changed, 35 insertions(+), 13 deletions(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 36b6c6460..dacb81dec 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -3,7 +3,24 @@
 
 What happens when objects are added `obj1 + obj2`, subtracted `obj1 - obj2` or printed using `alert(obj)`?
 
-In that case, objects are auto-converted to primitives, and then the operation is carried out.
+JavaScript doesn't exactly allow to customize how operators work on objects. Unlike some other programming languages, such as Ruby or C++, we can't implement a special object method to handle an addition (or other operators).
+
+In case of such operations, objects are auto-converted to primitives, and then the operation is carried out over these primitives and results in a primitive value.
+
+That's an important limitation, as the result of `obj1 + obj2` can't be another object!
+
+E.g. we can't make objects representing vectors or matrices (or archievements or whatever), add them and expect a "summed" object as the result. Such architectural feats are automatically "off the board".
+
+So, because we can't do much here, in real projects people don't do maths with objects. When it happens, it's usually because of coding mistake.
+
+In this chapter we'll cover how an object converts to primitive and how to customize it.
+
+We have two purposes:
+
+1. It will allow us to understand what's going on in case of coding mistakes, when such an operation happened accidentally.
+2. There are exceptions, where such operations are possible and look good. E.g. subtracting or comparing dates (`Date` objects). We'll come across them later.
+
+## Conversion rules
 
 In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to fill it.
 
@@ -11,11 +28,11 @@ In the chapter <info:type-conversions> we've seen the rules for numeric, string
 2. The numeric conversion happens when we subtract objects or apply mathematical functions. For instance, `Date` objects (to be covered in the chapter <info:date>) can be subtracted, and the result of `date1 - date2` is the time difference between two dates.
 3. As for the string conversion -- it usually happens when we output an object like `alert(obj)` and in similar contexts.
 
-## ToPrimitive
-
 We can fine-tune string and numeric conversion, using special object methods.
 
-There are three variants of type conversion, so-called "hints", described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
+There are three variants of type conversion, that happen in various situations.
+
+They're called "hints", as described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
 
 `"string"`
 : For an object-to-string conversion, when we're doing an operation on an object that expects a string, like `alert`:
@@ -82,11 +99,14 @@ Let's start from the first method. There's a built-in symbol named `Symbol.toPri
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
-  // must return a primitive value
+  // here goes the code to convert this object to a primitive
+  // it must return a primitive value
   // hint = one of "string", "number", "default"
 };
 ```
 
+If the method `Symbol.toPrimitive` exists, it's used for all hints, and no more methods are needed.
+
 For instance, here `user` object implements it:
 
 ```js run
@@ -111,12 +131,12 @@ As we can see from the code, `user` becomes a self-descriptive string or a money
 
 ## toString/valueOf
 
-Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
+If there's no `Symbol.toPrimitive` then JavaScript tries to find methods `toString` and `valueOf`:
 
-If there's no `Symbol.toPrimitive` then JavaScript tries to find them and try in the order:
+- For the "string" hint: `toString`, and if it doesn't exist, then `valueOf` (so `toString` has the priority for stirng conversions).
+- For other hints: `valueOf`, and if it doesn't exist, then `toString` (so `valueOf` has the priority for maths).
 
-- `toString -> valueOf` for "string" hint.
-- `valueOf -> toString` otherwise.
+Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
 
 These methods must return a primitive value. If `toString` or `valueOf` returns an object, then it's ignored (same as if there were no method).
 
@@ -136,9 +156,9 @@ alert(user.valueOf() === user); // true
 
 So if we try to use an object as a string, like in an `alert` or so, then by default we see `[object Object]`.
 
-And the default `valueOf` is mentioned here only for the sake of completeness, to avoid any confusion. As you can see, it returns the object itself, and so is ignored. Don't ask me why, that's for historical reasons. So we can assume it doesn't exist.
+The default `valueOf` is mentioned here only for the sake of completeness, to avoid any confusion. As you can see, it returns the object itself, and so is ignored. Don't ask me why, that's for historical reasons. So we can assume it doesn't exist.
 
-Let's implement these methods.
+Let's implement these methods to customize the conversion.
 
 For instance, here `user` does the same as above using a combination of `toString` and `valueOf` instead of `Symbol.toPrimitive`:
 
@@ -183,7 +203,7 @@ alert(user + 500); // toString -> John500
 
 In the absence of `Symbol.toPrimitive` and `valueOf`, `toString` will handle all primitive conversions.
 
-## Return types
+### A conversion can return any primitive type
 
 The important thing to know about all primitive-conversion methods is that they do not necessarily return the "hinted" primitive.
 
@@ -252,4 +272,6 @@ The conversion algorithm is:
 3. Otherwise if hint is `"number"` or `"default"`
     - try `obj.valueOf()` and `obj.toString()`, whatever exists.
 
-In practice, it's often enough to implement only `obj.toString()` as a "catch-all" method for all conversions that return a "human-readable" representation of an object, for logging or debugging purposes.  
+In practice, it's often enough to implement only `obj.toString()` as a "catch-all" method for string conversions that should return a "human-readable" representation of an object, for logging or debugging purposes.  
+
+As for math operations, JavaScript doesn't provide a way to "override" them using methods, so real life projects rarely use them on objects.
\ No newline at end of file

From 614e29e99a0e474d379a28b2e68be82ec858c099 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 14 Jun 2021 01:49:46 +0300
Subject: [PATCH 68/71] minor fixes

---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index dacb81dec..d0d797d88 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -11,7 +11,7 @@ That's an important limitation, as the result of `obj1 + obj2` can't be another
 
 E.g. we can't make objects representing vectors or matrices (or archievements or whatever), add them and expect a "summed" object as the result. Such architectural feats are automatically "off the board".
 
-So, because we can't do much here, in real projects people don't do maths with objects. When it happens, it's usually because of coding mistake.
+So, because we can't do much here, in real projects people don't do maths with objects. When it happens, it's usually because of a coding mistake.
 
 In this chapter we'll cover how an object converts to primitive and how to customize it.
 

From a171b0a24f23a82b9da8385d98eb7bee9c007953 Mon Sep 17 00:00:00 2001
From: Z Yin <z.yin.md@gmail.com>
Date: Sun, 13 Jun 2021 18:51:33 -0400
Subject: [PATCH 69/71] fix typo in 1-js/05-data-types/03-string

---
 1-js/05-data-types/03-string/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index d5bda9690..3b07eccad 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -526,7 +526,7 @@ Now it becomes obvious why `a > Z`.
 The characters are compared by their numeric code. The greater code means that the character is greater. The code for `a` (97) is greater than the code for `Z` (90).
 
 - All lowercase letters go after uppercase letters because their codes are greater.
-- Some letters like `Ö` stand apart from the main alphabet. Here, it's code is greater than anything from `a` to `z`.
+- Some letters like `Ö` stand apart from the main alphabet. Here, its code is greater than anything from `a` to `z`.
 
 ### Correct comparisons [#correct-comparisons]
 

From b258e8fd004b0a2ab83d3b22c16e037ef836091d Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Mon, 14 Jun 2021 10:21:27 +0300
Subject: [PATCH 70/71] minor fixes

---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index d0d797d88..b0605d44f 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -11,7 +11,7 @@ That's an important limitation, as the result of `obj1 + obj2` can't be another
 
 E.g. we can't make objects representing vectors or matrices (or archievements or whatever), add them and expect a "summed" object as the result. Such architectural feats are automatically "off the board".
 
-So, because we can't do much here, in real projects people don't do maths with objects. When it happens, it's usually because of a coding mistake.
+So, because we can't do much here, there's no maths with objects in real projects. When it happens, it's usually because of a coding mistake.
 
 In this chapter we'll cover how an object converts to primitive and how to customize it.
 

From fb4fc33a2234445808100ddc9f5e4dcec8b3d24c Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Tue, 15 Jun 2021 09:23:16 +0300
Subject: [PATCH 71/71] minor fixes

---
 1-js/04-object-basics/06-constructor-new/article.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 5c2bb9d74..184b30f86 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -70,7 +70,8 @@ Let's note once again -- technically, any function (except arrow functions, as t
 If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this:
 
 ```js
-let user = new function() {
+// create a function and immediately call it with new
+let user = new function() { 
   this.name = "John";
   this.isAdmin = false;