From bda37e2b7b9a0010619bf70b6355053baeb6edea Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Fri, 15 Jan 2021 12:14:53 -0500
Subject: [PATCH 01/25] Update article.md

Minor edits for grammar, phrasing, and markup.
---
 .../1-form-elements/article.md                 | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 6c7e18aca..748825d53 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -8,7 +8,7 @@ Working with forms will be much more convenient when we learn them.
 
 Document forms are members of the special collection `document.forms`.
 
-That's a so-called "named collection": it's both named and ordered. We can use both the name or the number in the document to get the form.
+That's a so-called <dfn>"named collection"</dfn>: it's both named and ordered. We can use both the name or the number in the document to get the form.
 
 ```js no-beautify
 document.forms.my - the form with name="my"
@@ -36,9 +36,9 @@ For instance:
 </script>
 ```
 
-There may be multiple elements with the same name, that's often the case with radio buttons.
+There may be multiple elements with the same name. This is often the case for radio buttons or checkboxes.
 
-In that case `form.elements[name]` is a collection, for instance:
+In these cases, `form.elements[name]` is a _collection_. For instance:
 
 ```html run height=40
 <form>
@@ -119,7 +119,7 @@ That's easy to see in an example:
 </script>
 ```
 
-That's usually not a problem, because we rarely change names of form elements.
+That's usually not a problem, however, because we rarely change names of form elements.
 
 ````
 
@@ -182,7 +182,7 @@ A `<select>` element has 3 important properties:
 
 They provide three different ways of setting a value for a `<select>`:
 
-1. Find the corresponding `<option>` element (e.g. among `select.options`) and set its `option.selected` to `true`.
+1. Find the corresponding `<option>` element (e.g., among `select.options`) and set its `option.selected` to `true`.
 2. If we know a new value: set `select.value` to the new value.
 3. If we know the new option number: set `select.selectedIndex` to that number.
 
@@ -204,7 +204,7 @@ Here is an example of all three methods:
 </script>
 ```
 
-Unlike most other controls, `<select>` allows to select multiple options at once if it has `multiple` attribute. This attribute is rarely used though.
+Unlike most other controls, `<select>` allows to select multiple options at once if it has `multiple` attribute. This attribute is rarely used, though.
 
 For multiple selected values, use the first way of setting values: add/remove the `selected` property from `<option>` subelements.
 
@@ -246,7 +246,7 @@ This syntax is optional. We can use `document.createElement('option')` and set a
 
 The difference between `defaultSelected` and `selected` is that `defaultSelected` sets the HTML-attribute (that we can get using `option.getAttribute('selected')`, while `selected` sets whether the option is selected or not.
 
-In practice, we usually should set both values to `true` or `false` (or omit, that's the same as `false`).
+In practice, you should usually set _both_ values to `true` or `false` (or omit; that's the same as `false`).
 
 For instance, here's a new "unselected" option:
 
@@ -289,9 +289,9 @@ Form navigation:
 `element.form`
 : Elements reference their form in the `form` property.
 
-Value is available as `input.value`, `textarea.value`, `select.value` etc, or `input.checked` for checkboxes and radio buttons.
+Value is available as `input.value`, `textarea.value`, `select.value`, etc. (or `input.checked` for checkboxes and radio buttons).
 
-For `<select>` we can also get the value by the index `select.selectedIndex` or through the options collection `select.options`.
+For `<select>`, we can also get the value by the index `select.selectedIndex` or through the options collection `select.options`.
 
 These are the basics to start working with forms. We'll meet many examples further in the tutorial.
 

From 18417c349d1ac4b35846a0e61bd00329388f4b8f Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Sat, 16 Jan 2021 16:35:37 -0500
Subject: [PATCH 02/25] Update article.md

Edited according to feedback
---
 2-ui/4-forms-controls/1-form-elements/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 748825d53..882b2d9e7 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -8,7 +8,7 @@ Working with forms will be much more convenient when we learn them.
 
 Document forms are members of the special collection `document.forms`.
 
-That's a so-called <dfn>"named collection"</dfn>: it's both named and ordered. We can use both the name or the number in the document to get the form.
+That's a so-called **"named collection"**: it's both named and ordered. We can use both the name or the number in the document to get the form.
 
 ```js no-beautify
 document.forms.my - the form with name="my"
@@ -38,7 +38,7 @@ For instance:
 
 There may be multiple elements with the same name. This is often the case for radio buttons or checkboxes.
 
-In these cases, `form.elements[name]` is a _collection_. For instance:
+In these cases, `form.elements[name]` is a *collection*. For instance:
 
 ```html run height=40
 <form>

From 8806d5b8ecb328c3f49883e373faa71cd0eec6d6 Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Sat, 16 Jan 2021 16:40:46 -0500
Subject: [PATCH 03/25] Update article.md

Rewrote phrasing pointed out in feedback
---
 2-ui/4-forms-controls/1-form-elements/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 882b2d9e7..9661f825a 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -36,9 +36,9 @@ For instance:
 </script>
 ```
 
-There may be multiple elements with the same name. This is often the case for radio buttons or checkboxes.
+There may be multiple elements with the same name. This is typical with radio buttons and checkboxes.
 
-In these cases, `form.elements[name]` is a *collection*. For instance:
+In that case, `form.elements[name]` is a *collection*. For instance:
 
 ```html run height=40
 <form>

From 93b1051687a06152c4131273225b8014259b33b4 Mon Sep 17 00:00:00 2001
From: VibingCreator <VibingCreator.Workspace@gmail.com>
Date: Mon, 25 Jan 2021 01:30:00 +0100
Subject: [PATCH 04/25] unify content with cosmetic changes

---
 .../1-finally-or-code-after/solution.md       |  10 +-
 .../1-finally-or-code-after/task.md           |   8 +-
 1-js/10-error-handling/1-try-catch/article.md | 134 +++++++++---------
 .../1-try-catch/try-catch-flow.svg            |   1 -
 4 files changed, 76 insertions(+), 77 deletions(-)
 delete mode 100644 1-js/10-error-handling/1-try-catch/try-catch-flow.svg

diff --git a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md
index 303431d6d..ec0dabc9a 100644
--- a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md
+++ b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md
@@ -1,8 +1,8 @@
 The difference becomes obvious when we look at the code inside a function.
 
-The behavior is different if there's a "jump out" of `try..catch`.
+The behavior is different if there's a "jump out" of `try...catch`.
 
-For instance, when there's a `return` inside `try..catch`. The `finally` clause works in case of *any* exit from `try..catch`, even via the `return` statement: right after `try..catch` is done, but before the calling code gets the control.
+For instance, when there's a `return` inside `try...catch`. The `finally` clause works in case of *any* exit from `try...catch`, even via the `return` statement: right after `try...catch` is done, but before the calling code gets the control.
 
 ```js run
 function f() {
@@ -11,7 +11,7 @@ function f() {
 *!*
     return "result";
 */!*
-  } catch (e) {
+  } catch (err) {
     /// ...
   } finally {
     alert('cleanup!');
@@ -28,11 +28,11 @@ function f() {
   try {
     alert('start');
     throw new Error("an error");
-  } catch (e) {
+  } catch (err) {
     // ...
     if("can't handle the error") {
 *!*
-      throw e;
+      throw err;
 */!*
     }
 
diff --git a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
index c573cc232..b6dc81326 100644
--- a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
+++ b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
@@ -6,12 +6,12 @@ importance: 5
 
 Compare the two code fragments.
 
-1. The first one uses `finally` to execute the code after `try..catch`:
+1. The first one uses `finally` to execute the code after `try...catch`:
 
     ```js
     try {
       work work
-    } catch (e) {
+    } catch (err) {
       handle errors
     } finally {
     *!*
@@ -19,12 +19,12 @@ Compare the two code fragments.
     */!*
     }
     ```
-2. The second fragment puts the cleaning right after `try..catch`:
+2. The second fragment puts the cleaning right after `try...catch`:
 
     ```js
     try {
       work work
-    } catch (e) {
+    } catch (err) {
       handle errors
     }
 
diff --git a/1-js/10-error-handling/1-try-catch/article.md b/1-js/10-error-handling/1-try-catch/article.md
index 3a2dc4ed4..a928da289 100644
--- a/1-js/10-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -1,14 +1,14 @@
-# Error handling, "try..catch"
+# Error handling, "try...catch"
 
 No matter how great we are at programming, sometimes our scripts have errors. They may occur because of our mistakes, an unexpected user input, an erroneous server response, and for a thousand other reasons.
 
 Usually, a script "dies" (immediately stops) in case of an error, printing it to console.
 
-But there's a syntax construct `try..catch` that allows us to "catch" errors so the script can, instead of dying, do something more reasonable.
+But there's a syntax construct `try...catch` that allows us to "catch" errors so the script can, instead of dying, do something more reasonable.
 
-## The "try..catch" syntax
+## The "try...catch" syntax
 
-The `try..catch` construct has two main blocks: `try`, and then `catch`:
+The `try...catch` construct has two main blocks: `try`, and then `catch`:
 
 ```js
 try {
@@ -25,12 +25,12 @@ try {
 It works like this:
 
 1. First, the code in `try {...}` is executed.
-2. If there were no errors, then `catch(err)` is ignored: the execution reaches the end of `try` and goes on, skipping `catch`.
-3. If an error occurs, then the `try` execution is stopped, and control flows to the beginning of `catch(err)`. The `err` variable (we can use any name for it) will contain an error object with details about what happened.
+2. If there were no errors, then `catch (err)` is ignored: the execution reaches the end of `try` and goes on, skipping `catch`.
+3. If an error occurs, then the `try` execution is stopped, and control flows to the beginning of `catch (err)`. The `err` variable (we can use any name for it) will contain an error object with details about what happened.
 
 ![](try-catch-flow.svg)
 
-So, an error inside the `try {…}` block does not kill the script -- we have a chance to handle it in `catch`.
+So, an error inside the `try {...}` block does not kill the script -- we have a chance to handle it in `catch`.
 
 Let's look at some examples.
 
@@ -45,7 +45,7 @@ Let's look at some examples.
 
       alert('End of try runs');   // *!*(2) <--*/!*
 
-    } catch(err) {
+    } catch (err) {
 
       alert('Catch is ignored, because there are no errors'); // (3)
 
@@ -64,7 +64,7 @@ Let's look at some examples.
 
       alert('End of try (never reached)');  // (2)
 
-    } catch(err) {
+    } catch (err) {
 
       alert(`Error has occurred!`); // *!*(3) <--*/!*
 
@@ -72,45 +72,45 @@ Let's look at some examples.
     ```
 
 
-````warn header="`try..catch` only works for runtime errors"
-For `try..catch` to work, the code must be runnable. In other words, it should be valid JavaScript.
+````warn header="`try...catch` only works for runtime errors"
+For `try...catch` to work, the code must be runnable. In other words, it should be valid JavaScript.
 
 It won't work if the code is syntactically wrong, for instance it has unmatched curly braces:
 
 ```js run
 try {
   {{{{{{{{{{{{
-} catch(e) {
+} catch (err) {
   alert("The engine can't understand this code, it's invalid");
 }
 ```
 
 The JavaScript engine first reads the code, and then runs it. The errors that occur on the reading phase are called "parse-time" errors and are unrecoverable (from inside that code). That's because the engine can't understand the code.
 
-So, `try..catch` can only handle errors that occur in valid code. Such errors are called "runtime errors" or, sometimes, "exceptions".
+So, `try...catch` can only handle errors that occur in valid code. Such errors are called "runtime errors" or, sometimes, "exceptions".
 ````
 
 
-````warn header="`try..catch` works synchronously"
-If an exception happens in "scheduled" code, like in `setTimeout`, then `try..catch` won't catch it:
+````warn header="`try...catch` works synchronously"
+If an exception happens in "scheduled" code, like in `setTimeout`, then `try...catch` won't catch it:
 
 ```js run
 try {
   setTimeout(function() {
     noSuchVariable; // script will die here
   }, 1000);
-} catch (e) {
+} catch (err) {
   alert( "won't work" );
 }
 ```
 
-That's because the function itself is executed later, when the engine has already left the `try..catch` construct.
+That's because the function itself is executed later, when the engine has already left the `try...catch` construct.
 
-To catch an exception inside a scheduled function, `try..catch` must be inside that function:
+To catch an exception inside a scheduled function, `try...catch` must be inside that function:
 ```js run
 setTimeout(function() {
   try {    
-    noSuchVariable; // try..catch handles the error!
+    noSuchVariable; // try...catch handles the error!
   } catch {
     alert( "error is caught here!" );
   }
@@ -125,7 +125,7 @@ When an error occurs, JavaScript generates an object containing the details abou
 ```js
 try {
   // ...
-} catch(err) { // <-- the "error object", could use another word instead of err
+} catch (err) { // <-- the "error object", could use another word instead of err
   // ...
 }
 ```
@@ -150,7 +150,7 @@ try {
 *!*
   lalala; // error, variable is not defined!
 */!*
-} catch(err) {
+} catch (err) {
   alert(err.name); // ReferenceError
   alert(err.message); // lalala is not defined
   alert(err.stack); // ReferenceError: lalala is not defined at (...call stack)
@@ -175,9 +175,9 @@ try {
 }
 ```
 
-## Using "try..catch"
+## Using "try...catch"
 
-Let's explore a real-life use case of `try..catch`.
+Let's explore a real-life use case of `try...catch`.
 
 As we already know, JavaScript supports the [JSON.parse(str)](mdn:js/JSON/parse) method to read JSON-encoded values.
 
@@ -205,7 +205,7 @@ Should we be satisfied with that? Of course not!
 
 This way, if something's wrong with the data, the visitor will never know that (unless they open the developer console). And people really don't like when something "just dies" without any error message.
 
-Let's use `try..catch` to handle the error:
+Let's use `try...catch` to handle the error:
 
 ```js run
 let json = "{ bad json }";
@@ -217,12 +217,12 @@ try {
 */!*
   alert( user.name ); // doesn't work
 
-} catch (e) {
+} catch (err) {
 *!*
   // ...the execution jumps here
   alert( "Our apologies, the data has errors, we'll try to request it one more time." );
-  alert( e.name );
-  alert( e.message );
+  alert( err.name );
+  alert( err.message );
 */!*
 }
 ```
@@ -245,7 +245,7 @@ try {
   alert( user.name ); // no name!
 */!*
 
-} catch (e) {
+} catch (err) {
   alert( "doesn't execute" );
 }
 ```
@@ -294,11 +294,11 @@ Let's see what kind of error `JSON.parse` generates:
 ```js run
 try {
   JSON.parse("{ bad json o_O }");
-} catch(e) {
+} catch (err) {
 *!*
-  alert(e.name); // SyntaxError
+  alert(err.name); // SyntaxError
 */!*
-  alert(e.message); // Unexpected token b in JSON at position 2
+  alert(err.message); // Unexpected token b in JSON at position 2
 }
 ```
 
@@ -323,8 +323,8 @@ try {
 
   alert( user.name );
 
-} catch(e) {
-  alert( "JSON Error: " + e.message ); // JSON Error: Incomplete data: no name
+} catch (err) {
+  alert( "JSON Error: " + err.message ); // JSON Error: Incomplete data: no name
 }
 ```
 
@@ -334,7 +334,7 @@ Now `catch` became a single place for all error handling: both for `JSON.parse`
 
 ## Rethrowing
 
-In the example above we use `try..catch` to handle incorrect data. But is it possible that *another unexpected error* occurs within the `try {...}` block? Like a programming error (variable is not defined) or something else, not just this "incorrect data" thing.
+In the example above we use `try...catch` to handle incorrect data. But is it possible that *another unexpected error* occurs within the `try {...}` block? Like a programming error (variable is not defined) or something else, not just this "incorrect data" thing.
 
 For example:
 
@@ -345,7 +345,7 @@ try {
   user = JSON.parse(json); // <-- forgot to put "let" before user
 
   // ...
-} catch(err) {
+} catch (err) {
   alert("JSON Error: " + err); // JSON Error: ReferenceError: user is not defined
   // (no JSON Error actually)
 }
@@ -353,7 +353,7 @@ try {
 
 Of course, everything's possible! Programmers do make mistakes. Even in open-source utilities used by millions for decades -- suddenly a bug may be discovered that leads to terrible hacks.
 
-In our case, `try..catch` is placed to catch "incorrect data" errors. But by its nature, `catch` gets *all* errors from `try`. Here it gets an unexpected error, but still shows the same `"JSON Error"` message. That's wrong and also makes the code more difficult to debug.
+In our case, `try...catch` is placed to catch "incorrect data" errors. But by its nature, `catch` gets *all* errors from `try`. Here it gets an unexpected error, but still shows the same `"JSON Error"` message. That's wrong and also makes the code more difficult to debug.
 
 To avoid such problems, we can employ the "rethrowing" technique. The rule is simple:
 
@@ -362,7 +362,7 @@ To avoid such problems, we can employ the "rethrowing" technique. The rule is si
 The "rethrowing" technique can be explained in more detail as:
 
 1. Catch gets all errors.
-2. In the `catch(err) {...}` block we analyze the error object `err`.
+2. In the `catch (err) {...}` block we analyze the error object `err`.
 3. If we don't know how to handle it, we do `throw err`.
 
 Usually, we can check the error type using the `instanceof` operator:
@@ -370,7 +370,7 @@ Usually, we can check the error type using the `instanceof` operator:
 ```js run
 try {
   user = { /*...*/ };
-} catch(err) {
+} catch (err) {
 *!*
   if (err instanceof ReferenceError) {
 */!*
@@ -399,24 +399,24 @@ try {
 
   alert( user.name );
 
-} catch(e) {
+} catch (err) {
 
 *!*
-  if (e instanceof SyntaxError) {
-    alert( "JSON Error: " + e.message );
+  if (err instanceof SyntaxError) {
+    alert( "JSON Error: " + err.message );
   } else {
-    throw e; // rethrow (*)
+    throw err; // rethrow (*)
   }
 */!*
 
 }
 ```
 
-The error throwing on line `(*)` from inside `catch` block "falls out" of `try..catch` and can be either caught by an outer `try..catch` construct (if it exists), or it kills the script.
+The error throwing on line `(*)` from inside `catch` block "falls out" of `try...catch` and can be either caught by an outer `try...catch` construct (if it exists), or it kills the script.
 
 So the `catch` block actually handles only errors that it knows how to deal with and "skips" all others.
 
-The example below demonstrates how such errors can be caught by one more level of `try..catch`:
+The example below demonstrates how such errors can be caught by one more level of `try...catch`:
 
 ```js run
 function readData() {
@@ -427,11 +427,11 @@ function readData() {
 *!*
     blabla(); // error!
 */!*
-  } catch (e) {
+  } catch (err) {
     // ...
-    if (!(e instanceof SyntaxError)) {
+    if (!(err instanceof SyntaxError)) {
 *!*
-      throw e; // rethrow (don't know how to deal with it)
+      throw err; // rethrow (don't know how to deal with it)
 */!*
     }
   }
@@ -439,20 +439,20 @@ function readData() {
 
 try {
   readData();
-} catch (e) {
+} catch (err) {
 *!*
-  alert( "External catch got: " + e ); // caught it!
+  alert( "External catch got: " + err ); // caught it!
 */!*
 }
 ```
 
-Here `readData` only knows how to handle `SyntaxError`, while the outer `try..catch` knows how to handle everything.
+Here `readData` only knows how to handle `SyntaxError`, while the outer `try...catch` knows how to handle everything.
 
-## try..catch..finally
+## try...catch...finally
 
 Wait, that's not all.
 
-The `try..catch` construct may have one more code clause: `finally`.
+The `try...catch` construct may have one more code clause: `finally`.
 
 If it exists, it runs in all cases:
 
@@ -464,7 +464,7 @@ The extended syntax looks like this:
 ```js
 *!*try*/!* {
    ... try to execute the code ...
-} *!*catch*/!*(e) {
+} *!*catch*/!* (err) {
    ... handle errors ...
 } *!*finally*/!* {
    ... execute always ...
@@ -477,7 +477,7 @@ Try running this code:
 try {
   alert( 'try' );
   if (confirm('Make an error?')) BAD_CODE();
-} catch (e) {
+} catch (err) {
   alert( 'catch' );
 } finally {
   alert( 'finally' );
@@ -513,7 +513,7 @@ let start = Date.now();
 
 try {
   result = fib(num);
-} catch (e) {
+} catch (err) {
   result = 0;
 *!*
 } finally {
@@ -531,14 +531,14 @@ You can check by running the code with entering `35` into `prompt` -- it execute
 In other words, the function may finish with `return` or `throw`, that doesn't matter. The `finally` clause executes in both cases.
 
 
-```smart header="Variables are local inside `try..catch..finally`"
-Please note that `result` and `diff` variables in the code above are declared *before* `try..catch`.
+```smart header="Variables are local inside `try...catch...finally`"
+Please note that `result` and `diff` variables in the code above are declared *before* `try...catch`.
 
 Otherwise, if we declared `let` in `try` block, it would only be visible inside of it.
 ```
 
 ````smart header="`finally` and `return`"
-The `finally` clause works for *any* exit from `try..catch`. That includes an explicit `return`.
+The `finally` clause works for *any* exit from `try...catch`. That includes an explicit `return`.
 
 In the example below, there's a `return` in `try`. In this case, `finally` is executed just before the control returns to the outer code.
 
@@ -550,7 +550,7 @@ function func() {
     return 1;
 */!*
 
-  } catch (e) {
+  } catch (err) {
     /* ... */
   } finally {
 *!*
@@ -563,9 +563,9 @@ alert( func() ); // first works alert from finally, and then this one
 ```
 ````
 
-````smart header="`try..finally`"
+````smart header="`try...finally`"
 
-The `try..finally` construct, without `catch` clause, is also useful. We apply it when we don't want to handle errors here (let them fall through), but want to be sure that processes that we started are finalized.
+The `try...finally` construct, without `catch` clause, is also useful. We apply it when we don't want to handle errors here (let them fall through), but want to be sure that processes that we started are finalized.
 
 ```js
 function func() {
@@ -586,7 +586,7 @@ In the code above, an error inside `try` always falls out, because there's no `c
 The information from this section is not a part of the core JavaScript.
 ```
 
-Let's imagine we've got a fatal error outside of `try..catch`, and the script died. Like a programming error or some other terrible thing.
+Let's imagine we've got a fatal error outside of `try...catch`, and the script died. Like a programming error or some other terrible thing.
 
 Is there a way to react on such occurrences? We may want to log the error, show something to the user (normally they don't see error messages), etc.
 
@@ -643,14 +643,14 @@ They work like this:
 
 ## Summary
 
-The `try..catch` construct allows to handle runtime errors. It literally allows to "try" running the code and "catch" errors that may occur in it.
+The `try...catch` construct allows to handle runtime errors. It literally allows to "try" running the code and "catch" errors that may occur in it.
 
 The syntax is:
 
 ```js
 try {
   // run this code
-} catch(err) {
+} catch (err) {
   // if an error happened, then jump here
   // err is the error object
 } finally {
@@ -658,7 +658,7 @@ try {
 }
 ```
 
-There may be no `catch` section or no `finally`, so shorter constructs `try..catch` and `try..finally` are also valid.
+There may be no `catch` section or no `finally`, so shorter constructs `try...catch` and `try...finally` are also valid.
 
 Error objects have following properties:
 
@@ -666,10 +666,10 @@ Error objects have following properties:
 - `name` -- the string with error name (error constructor name).
 - `stack` (non-standard, but well-supported) -- the stack at the moment of error creation.
 
-If an error object is not needed, we can omit it by using `catch {` instead of `catch(err) {`.
+If an error object is not needed, we can omit it by using `catch {` instead of `catch (err) {`.
 
 We can also generate our own errors using the `throw` operator. Technically, the argument of `throw` can be anything, but usually it's an error object inheriting from the built-in `Error` class. More on extending errors in the next chapter.
 
 *Rethrowing* is a very important pattern of error handling: a `catch` block usually expects and knows how to handle the particular error type, so it should rethrow errors it doesn't know.
 
-Even if we don't have `try..catch`, most environments allow us to setup a "global" error handler to catch errors that "fall out". In-browser, that's `window.onerror`.
+Even if we don't have `try...catch`, most environments allow us to setup a "global" error handler to catch errors that "fall out". In-browser, that's `window.onerror`.
diff --git a/1-js/10-error-handling/1-try-catch/try-catch-flow.svg b/1-js/10-error-handling/1-try-catch/try-catch-flow.svg
deleted file mode 100644
index ac816e356..000000000
--- a/1-js/10-error-handling/1-try-catch/try-catch-flow.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="514" height="411" viewBox="0 0 514 411"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="try-catch-flow.svg"><g id="Rectangle-1-+-Корень" transform="translate(207 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="14"/><text id="Begin" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21" y="20">Begin</tspan></text></g><path id="Line" fill="#EE6B47" fill-rule="nonzero" d="M249 34v23.049l8 .001-9.5 19-9.5-19 8-.001V34h3z"/><path id="Line-Copy" fill="#EE6B47" fill-rule="nonzero" d="M399 297v23.049l8 .001-9.5 19-9.5-19 8-.001V297h3z"/><path id="Path-1218" fill="#EE6B47" fill-rule="nonzero" d="M158.5 131.5v3h-59v85h8l-9.5 19-9.5-19h8v-88h62z"/><path id="Path-1218-Copy" fill="#EE6B47" fill-rule="nonzero" d="M400.5 131.5l-.001 88h8.001l-9.5 19-9.5-19h7.999v-85H315.5v-3h85z"/><g id="Rectangle-354-+-Каково-“официальное”" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" transform="translate(154 81)"><path id="Rectangle-354" d="M2.06 52l91.55 50.856L185.161 52 93.611 1.144 2.058 52z"/></g><g id="Rectangle-356-+-Отмена" transform="translate(59 177)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="No-Errors" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.5" y="15">No Errors</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”" transform="translate(303 176)"><path id="Rectangle-356-Copy" fill="#FFF" d="M65 2h60v20H65z"/><text id="An-error-occured-in" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x=".932" y="15">An error occured in the code</tspan></text></g><rect id="Rectangle-1-Copy-2" width="214" height="49" x="292" y="349" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><rect id="Rectangle-1" width="195" height="49" x="1" y="244" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><rect id="Rectangle-1-Copy" width="216" height="49" x="290" y="244" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><text id="Ignore-catch-block" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="39" y="272">Ignore catch block</tspan></text><text id="Ignore-the-rest-of-t" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="332" y="272">Ignore the rest of try</tspan></text><text id="Execute-catch-block" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="333" y="379">Execute catch block</tspan></text><text id="try-{-}" fill="#8A704D" font-family="PTMono-Regular, PT Mono" font-size="14" font-weight="normal"><tspan x="218" y="117">try {</tspan>    <tspan x="218" y="157">}</tspan></text><text id="//-code..." fill="#8A704D" font-family="PTMono-Regular, PT Mono" font-size="14" font-weight="normal"><tspan x="232" y="138">// code...</tspan></text></g></g></svg>
\ No newline at end of file

From ad012798ea2e19eb65413b270233c6f123912669 Mon Sep 17 00:00:00 2001
From: VibingCreator <VibingCreator.Workspace@gmail.com>
Date: Mon, 25 Jan 2021 01:34:29 +0100
Subject: [PATCH 05/25] restore try-catch-flow.svg

---
 1-js/10-error-handling/1-try-catch/try-catch-flow.svg | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 1-js/10-error-handling/1-try-catch/try-catch-flow.svg

diff --git a/1-js/10-error-handling/1-try-catch/try-catch-flow.svg b/1-js/10-error-handling/1-try-catch/try-catch-flow.svg
new file mode 100644
index 000000000..ac816e356
--- /dev/null
+++ b/1-js/10-error-handling/1-try-catch/try-catch-flow.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="514" height="411" viewBox="0 0 514 411"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="try-catch-flow.svg"><g id="Rectangle-1-+-Корень" transform="translate(207 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="14"/><text id="Begin" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21" y="20">Begin</tspan></text></g><path id="Line" fill="#EE6B47" fill-rule="nonzero" d="M249 34v23.049l8 .001-9.5 19-9.5-19 8-.001V34h3z"/><path id="Line-Copy" fill="#EE6B47" fill-rule="nonzero" d="M399 297v23.049l8 .001-9.5 19-9.5-19 8-.001V297h3z"/><path id="Path-1218" fill="#EE6B47" fill-rule="nonzero" d="M158.5 131.5v3h-59v85h8l-9.5 19-9.5-19h8v-88h62z"/><path id="Path-1218-Copy" fill="#EE6B47" fill-rule="nonzero" d="M400.5 131.5l-.001 88h8.001l-9.5 19-9.5-19h7.999v-85H315.5v-3h85z"/><g id="Rectangle-354-+-Каково-“официальное”" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" transform="translate(154 81)"><path id="Rectangle-354" d="M2.06 52l91.55 50.856L185.161 52 93.611 1.144 2.058 52z"/></g><g id="Rectangle-356-+-Отмена" transform="translate(59 177)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="No-Errors" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.5" y="15">No Errors</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”" transform="translate(303 176)"><path id="Rectangle-356-Copy" fill="#FFF" d="M65 2h60v20H65z"/><text id="An-error-occured-in" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x=".932" y="15">An error occured in the code</tspan></text></g><rect id="Rectangle-1-Copy-2" width="214" height="49" x="292" y="349" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><rect id="Rectangle-1" width="195" height="49" x="1" y="244" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><rect id="Rectangle-1-Copy" width="216" height="49" x="290" y="244" fill="#FFF9EB" stroke="#E8C48E" stroke-width="2" rx="24.5"/><text id="Ignore-catch-block" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="39" y="272">Ignore catch block</tspan></text><text id="Ignore-the-rest-of-t" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="332" y="272">Ignore the rest of try</tspan></text><text id="Execute-catch-block" fill="#8A704D" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="333" y="379">Execute catch block</tspan></text><text id="try-{-}" fill="#8A704D" font-family="PTMono-Regular, PT Mono" font-size="14" font-weight="normal"><tspan x="218" y="117">try {</tspan>    <tspan x="218" y="157">}</tspan></text><text id="//-code..." fill="#8A704D" font-family="PTMono-Regular, PT Mono" font-size="14" font-weight="normal"><tspan x="232" y="138">// code...</tspan></text></g></g></svg>
\ No newline at end of file

From b93be7398add9c0749ade17cdf6483c56d7a4a03 Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Mon, 25 Jan 2021 10:55:45 -0500
Subject: [PATCH 06/25] Update article.md

---
 2-ui/4-forms-controls/1-form-elements/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 9661f825a..f4df7b129 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -8,7 +8,7 @@ Working with forms will be much more convenient when we learn them.
 
 Document forms are members of the special collection `document.forms`.
 
-That's a so-called **"named collection"**: it's both named and ordered. We can use both the name or the number in the document to get the form.
+That's a so-called *"named collection"*: it's both named and ordered. We can use both the name or the number in the document to get the form.
 
 ```js no-beautify
 document.forms.my - the form with name="my"

From d78ce9ca32adf8fde98d5476195cbbba470dfe6b Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Mon, 25 Jan 2021 11:01:01 -0500
Subject: [PATCH 07/25] Update article.md

---
 2-ui/4-forms-controls/1-form-elements/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index f4df7b129..0cf5232f6 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -246,7 +246,7 @@ This syntax is optional. We can use `document.createElement('option')` and set a
 
 The difference between `defaultSelected` and `selected` is that `defaultSelected` sets the HTML-attribute (that we can get using `option.getAttribute('selected')`, while `selected` sets whether the option is selected or not.
 
-In practice, you should usually set _both_ values to `true` or `false` (or omit; that's the same as `false`).
+In practice, one should usually set _both_ values to `true` or `false`. (Or, simply omit them; both default to `false`.)
 
 For instance, here's a new "unselected" option:
 

From 4711ee4e85679f3a799e1bc3bad8e6950ad57ee3 Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Mon, 25 Jan 2021 11:03:51 -0500
Subject: [PATCH 08/25] Update article.md

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

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 0cf5232f6..4bb65ed4e 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -289,9 +289,9 @@ Form navigation:
 `element.form`
 : Elements reference their form in the `form` property.
 
-Value is available as `input.value`, `textarea.value`, `select.value`, etc. (or `input.checked` for checkboxes and radio buttons).
+Value is available as `input.value`, `textarea.value`, `select.value`, etc. (For checkboxes and radio buttons, use `input.checked` to determine whether a value is selected.)
 
-For `<select>`, we can also get the value by the index `select.selectedIndex` or through the options collection `select.options`.
+For `<select>`, one can also get the value by the index `select.selectedIndex` or through the options collection `select.options`.
 
 These are the basics to start working with forms. We'll meet many examples further in the tutorial.
 

From 7be7b28a97d63648082927588056148084dfda02 Mon Sep 17 00:00:00 2001
From: Mikita Chyzhyk <mikitachyzhyk@gmail.com>
Date: Tue, 2 Feb 2021 14:13:12 +0300
Subject: [PATCH 09/25] Considering Promise.any there are 6 static methods

---
 1-js/11-async/05-promise-api/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/11-async/05-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
index 38e13397e..2375f1e74 100644
--- a/1-js/11-async/05-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -1,6 +1,6 @@
 # Promise API
 
-There are 5 static methods in the `Promise` class. We'll quickly cover their use cases here.
+There are 6 static methods in the `Promise` class. We'll quickly cover their use cases here.
 
 ## Promise.all
 

From f0145341c27276aa635c995017d3968ef00758a4 Mon Sep 17 00:00:00 2001
From: Zearin <Zearin@users.noreply.github.com>
Date: Tue, 2 Feb 2021 12:49:33 -0500
Subject: [PATCH 10/25] Remove comma after `e.g.` based on feedback

---
 2-ui/4-forms-controls/1-form-elements/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 4bb65ed4e..18a316cf0 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -182,7 +182,7 @@ A `<select>` element has 3 important properties:
 
 They provide three different ways of setting a value for a `<select>`:
 
-1. Find the corresponding `<option>` element (e.g., among `select.options`) and set its `option.selected` to `true`.
+1. Find the corresponding `<option>` element (e.g. among `select.options`) and set its `option.selected` to `true`.
 2. If we know a new value: set `select.value` to the new value.
 3. If we know the new option number: set `select.selectedIndex` to that number.
 

From 0d52720bc04eeb35d769dbcd3392c5beda4a62b5 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Thu, 4 Feb 2021 11:49:03 -0300
Subject: [PATCH 11/25] needed 4 translated repos

---
 1-js/02-first-steps/11-logical-operators/article.md     | 2 +-
 1-js/04-object-basics/02-object-copy/article.md         | 2 +-
 1-js/05-data-types/03-string/article.md                 | 2 +-
 1-js/09-classes/03-static-properties-methods/article.md | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 0842bf339..97f5d738a 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -64,7 +64,7 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## OR "||" finds the first truthy value
+## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
 
 The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
 
diff --git a/1-js/04-object-basics/02-object-copy/article.md b/1-js/04-object-basics/02-object-copy/article.md
index 52af1bdc5..318fc04a4 100644
--- a/1-js/04-object-basics/02-object-copy/article.md
+++ b/1-js/04-object-basics/02-object-copy/article.md
@@ -100,7 +100,7 @@ alert( a == b ); // false
 
 For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely -- usually they appear as a result of a programming mistake.
 
-## Cloning and merging, Object.assign
+## Cloning and merging, Object.assign [#cloning-and-merging-object-assign]
 
 So, copying an object variable creates one more reference to the same object.
 
diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index 4b8e8aa8a..d5bda9690 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -528,7 +528,7 @@ The characters are compared by their numeric code. The greater code means that t
 - 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`.
 
-### Correct comparisons
+### Correct comparisons [#correct-comparisons]
 
 The "right" algorithm to do string comparisons is more complex than it may seem, because alphabets are different for different languages.
 
diff --git a/1-js/09-classes/03-static-properties-methods/article.md b/1-js/09-classes/03-static-properties-methods/article.md
index ab08f2ded..c75ec257f 100644
--- a/1-js/09-classes/03-static-properties-methods/article.md
+++ b/1-js/09-classes/03-static-properties-methods/article.md
@@ -125,7 +125,7 @@ That is the same as a direct assignment to `Article`:
 Article.publisher = "Ilya Kantor";
 ```
 
-## Inheritance of static properties and methods
+## Inheritance of static properties and methods [#statics-and-inheritance]
 
 Static properties and methods are inherited.
 

From c8a52a182bd6d0034698c9973b98f6f17212a680 Mon Sep 17 00:00:00 2001
From: Knox Jarvis <45022934+knoxj1@users.noreply.github.com>
Date: Thu, 4 Feb 2021 18:24:48 -0500
Subject: [PATCH 12/25] Add comments to article.md

I do not think it's likely but I do not want anyone to mistake those lines for legitimate JS expressions. I modified those two lines to match the format of pretty much every other comment in the article.
---
 2-ui/4-forms-controls/1-form-elements/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 6c7e18aca..860c1b86b 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -11,8 +11,8 @@ Document forms are members of the special collection `document.forms`.
 That's a so-called "named collection": it's both named and ordered. We can use both the name or the number in the document to get the form.
 
 ```js no-beautify
-document.forms.my - the form with name="my"
-document.forms[0] - the first form in the document
+document.forms.my; // the form with name="my"
+document.forms[0]  // the first form in the document
 ```
 
 When we have a form, then any element is available in the named collection `form.elements`.

From dd9833ccecb7624a7049361adc5244ea644af375 Mon Sep 17 00:00:00 2001
From: Knox Jarvis <45022934+knoxj1@users.noreply.github.com>
Date: Wed, 10 Feb 2021 10:34:10 -0500
Subject: [PATCH 13/25] Update 2-ui/4-forms-controls/1-form-elements/article.md

Co-authored-by: Muhammed Zakir <8190126+MuhammedZakir@users.noreply.github.com>
---
 2-ui/4-forms-controls/1-form-elements/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 860c1b86b..7ee502d34 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -12,7 +12,7 @@ That's a so-called "named collection": it's both named and ordered. We can use b
 
 ```js no-beautify
 document.forms.my; // the form with name="my"
-document.forms[0]  // the first form in the document
+document.forms[0]; // the first form in the document
 ```
 
 When we have a form, then any element is available in the named collection `form.elements`.

From 879554f082e70a65cdd4751f2f70ea08a3929413 Mon Sep 17 00:00:00 2001
From: fibretothepremises
 <65995595+fibretothepremises@users.noreply.github.com>
Date: Thu, 25 Feb 2021 09:48:46 +1100
Subject: [PATCH 14/25] Update article.md - fix syntax

Fix syntax
---
 1-js/06-advanced-functions/06-function-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index e93090290..12342f45a 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -326,7 +326,7 @@ welcome(); // Hello, Guest (nested call works)
 
 Now it works, because the name `"func"` is function-local. It is not taken from outside (and not visible there). The specification guarantees that it will always reference the current function.
 
-The outer code still has it's variable `sayHi` or `welcome`. And `func` is an "internal function name", how the function can call itself internally.
+The outer code still has its variable `sayHi` or `welcome`. And `func` is an "internal function name", how the function can call itself internally.
 
 ```smart header="There's no such thing for Function Declaration"
 The "internal name" feature described here is only available for Function Expressions, not for Function Declarations. For Function Declarations, there is no syntax for adding an "internal" name.

From f6ae0b5a5f3e48074312ca3e47c17c92a5a52328 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 28 Feb 2021 22:24:46 +0300
Subject: [PATCH 15/25] minor fixes

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 8c6a161a7..04cca7c86 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -33,7 +33,7 @@ In other words, such pattern means that we're looking for `pattern:X` followed b
 
 That's only possible if patterns `pattern:Y` and `pattern:Z` aren't mutually exclusive.
 
-For example, `pattern:\d+(?=\s)(?=.*30)` looks for `pattern:\d+` only if it's followed by a space, and there's `30` somewhere after it:
+For example, `pattern:\d+(?=\s)(?=.*30)` looks for `pattern:\d+` that is followed by a space `pattern:(?=\s)`, and there's `30` somewhere after it `pattern:(?=.*30)`:
 
 ```js run
 let str = "1 turkey costs 30€";

From f452810885b80e9c3c32c77c9dab095034be1a5d Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Mar 2021 10:28:52 -0300
Subject: [PATCH 16/25] typo

---
 .../2-insert-after-head/solution.md                             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
index f2bbd3f5b..b1d377d33 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
@@ -31,6 +31,6 @@ It works like this:
 
 The tag `pattern:<body.*?>` won't be returned. The result of this regexp is literally an empty string, but it matches only at positions preceeded by `pattern:<body.*?>`.
 
-So we replaces the "empty line", preceeded by `pattern:<body.*?>`, with `<h1>Hello</h1>`. That's the insertion after `<body>`.
+So it replaces the "empty line", preceeded by `pattern:<body.*?>`, with `<h1>Hello</h1>`. That's the insertion after `<body>`.
 
 P.S. Regexp flags, such as `pattern:s` and `pattern:i` can also be useful: `pattern:/<body.*?>/si`. The `pattern:s` flag makes the dot `pattern:.` match a newline character, and `pattern:i` flag makes `pattern:<body>` also match `match:<BODY>` case-insensitively.

From fdcf507c1c01ca2dd38b77f0c451fb1cb131ca70 Mon Sep 17 00:00:00 2001
From: Timur <T1mL3arn@users.noreply.github.com>
Date: Fri, 5 Mar 2021 12:50:25 +1000
Subject: [PATCH 17/25] Fix little formatting typo in 1.2.13 (loops)

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

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index b3e3953b8..a23531f12 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -318,7 +318,7 @@ alert('Done!');
 
 We need a way to stop the process if the user cancels the input.
 
-The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue!
+The ordinary `break` after `input` would only break the inner loop. That's not sufficient -- labels, come to the rescue!
 
 A *label* is an identifier with a colon before a loop:
 ```js

From d9d1023281bd298984ff7615f0c98fb7bc557fb4 Mon Sep 17 00:00:00 2001
From: Mustafa Kemal Tuna <12192118+lumosmind@users.noreply.github.com>
Date: Mon, 8 Mar 2021 15:43:00 +0300
Subject: [PATCH 18/25] spread operator vs spread syntax

it should be spread syntax
https://javascript.info/rest-parameters-spread
---
 1-js/04-object-basics/02-object-copy/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/02-object-copy/article.md b/1-js/04-object-basics/02-object-copy/article.md
index 52af1bdc5..55ed4a1a8 100644
--- a/1-js/04-object-basics/02-object-copy/article.md
+++ b/1-js/04-object-basics/02-object-copy/article.md
@@ -186,7 +186,7 @@ let clone = Object.assign({}, user);
 
 It copies all properties of `user` into the empty object and returns it.
 
-There are also other methods of cloning an object, e.g. using the [spread operator](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
+There are also other methods of cloning an object, e.g. using the [spread syntax](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
 
 ## Nested cloning
 

From a89de3548d809359df6402cce4608edae8ffdf44 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 09:38:06 +0300
Subject: [PATCH 19/25] closes #2498

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

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index a23531f12..56a59850a 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -363,12 +363,14 @@ Labels do not allow us to jump into an arbitrary place in the code.
 
 For example, it is impossible to do this:
 ```js
-break label; // doesn't jumps to the label below
+break label; // jump to the label below (doesn't work)
 
 label: for (...)
 ```
 
-A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive.
+A call to `continue` is only possible from inside the loop.
+
+The `break` directive may be placed before code blocks too, as `label: { ... }`, but it's almost never used like that. And it also works only inside-out.
 ````
 
 ## Summary

From 91aed383d9588edd3b9d778ac3ebea619ccc43e6 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 10:08:29 +0300
Subject: [PATCH 20/25] minor fixes

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

diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index 7fd7168b1..ab4d1ee29 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -475,9 +475,9 @@ There are two main types of search in an object store:
 1. By a key or a key range. That is: by `book.id` in our "books" storage.
 2. By another object field, e.g. `book.price`.
 
-First let's deal with the keys and key ranges `(1)`.
+First let's deal with the first type of search: by a key.
 
-Methods that involve searching support either exact keys or so-called "range queries" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) objects that specify a "key range".
+Searching methods support both exact keys and so-called "ranges" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) objects that specify an acceptable "key range".
 
 Ranges are created using following calls:
 
@@ -486,7 +486,7 @@ Ranges are created using following calls:
 - `IDBKeyRange.bound(lower, upper, [lowerOpen], [upperOpen])` means: between `lower` and `upper`. If the open flags is true, the corresponding key is not included in the range.
 - `IDBKeyRange.only(key)` -- a range that consists of only one `key`, rarely used.
 
-All searching methods accept a `query` argument that can be either an exact key or a key range:
+Searching methods accept a `query` argument that can be either an exact key or a key range:
 
 - `store.get(query)` -- search for the first value by a key or a range.
 - `store.getAll([query], [count])` -- search for all values, limit by `count` if given.
@@ -511,7 +511,7 @@ books.getAll(IDBKeyRange.upperBound('html', true))
 // get all books
 books.getAll()
 
-// get all keys: id > 'js'
+// get all keys, where id > 'js'
 books.getAllKeys(IDBKeyRange.lowerBound('js', true))
 ```
 

From 78f7678882fc18cfdc4859af8d8f51807d46990b Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 10:12:32 +0300
Subject: [PATCH 21/25] closes #2494

---
 1-js/13-modules/02-import-export/article.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
index 7f24d29ce..10e47820f 100644
--- a/1-js/13-modules/02-import-export/article.md
+++ b/1-js/13-modules/02-import-export/article.md
@@ -428,14 +428,14 @@ You can check yourself by reading them and recalling what they mean:
 
 Import:
 
-- Named exports from module:
+- Importing named exports:
   - `import {x [as y], ...} from "module"`
-- Default export:  
+- Importing the default export:  
   - `import x from "module"`
   - `import {default as x} from "module"`
-- Everything:
+- Import all:
   - `import * as obj from "module"`
-- Import the module (its code runs), but do not assign it to a variable:
+- Import the module (its code runs), but do not assign any of its exports to variables:
   - `import "module"`
 
 We can put `import/export` statements at the top or at the bottom of a script, that doesn't matter.

From c3a9bbdf490cc3d6b72a7d101e86dae4a60eecbb Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 15:57:12 +0300
Subject: [PATCH 22/25] minor fixes

---
 1-js/11-async/08-async-await/02-rewrite-async-2/solution.md | 2 +-
 6-data-storage/03-indexeddb/article.md                      | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
index 105948833..aa462dbf7 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
@@ -1,5 +1,5 @@
 
-There are no tricks here. Just replace `.catch` with `try...catch` inside `demoGithubUser` and add `async/await` where needed:
+There are no tricks here. Just replace `.catch` with `try..catch` inside `demoGithubUser` and add `async/await` where needed:
 
 ```js run
 class HttpError extends Error {
diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index ab4d1ee29..ee1e9a715 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -18,6 +18,12 @@ The native interface to IndexedDB, described in the specification <https://www.w
 
 We can also use `async/await` with the help of a promise-based wrapper, like <https://github.com/jakearchibald/idb>. That's pretty convenient, but the wrapper is not perfect, it can't replace events for all cases. So we'll start with events, and then, after we gain an understanding of IndexedDb, we'll use the wrapper.
 
+```smart header="Where's the data?"
+Technically, the data is usually stored in the visitor's home directory, along with browser settings, extensions, etc.
+
+Different browsers and OS-level users have each their own independant storage.
+```
+
 ## Open database
 
 To start working with IndexedDB, we first need to `open` (connect to) a database.

From 8bc505adcd26d80ef43481df70b7aa2f02e4a646 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 18:30:06 +0300
Subject: [PATCH 23/25] closes #2459

---
 5-network/06-fetch-api/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-network/06-fetch-api/article.md b/5-network/06-fetch-api/article.md
index d187526fb..e57689c75 100644
--- a/5-network/06-fetch-api/article.md
+++ b/5-network/06-fetch-api/article.md
@@ -171,7 +171,7 @@ The `redirect` option allows to change that:
 
 - **`"follow"`** -- the default, follow HTTP-redirects,
 - **`"error"`** -- error in case of HTTP-redirect,
-- **`"manual"`** -- don't follow HTTP-redirect, but `response.url` will be the new URL, and `response.redirected` will be `true`, so that we can perform the redirect manually to the new URL (if needed).
+- **`"manual"`** -- allows to process HTTP-redirects manually. In case of redirect, we'll get a special response object, with `response.type="opaqueredirect"` and and zeroed/empty status and most other properies.
 
 ## integrity
 

From bbf60dd3404bd20b5a4370106dc774050e816faa Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sat, 13 Mar 2021 23:21:10 +0300
Subject: [PATCH 24/25] minor fixes

---
 6-data-storage/03-indexeddb/article.md | 40 ++++++++++++++------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index ee1e9a715..a4fb78c1e 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -131,9 +131,7 @@ In order to organize that, the `versionchange` event triggers on the "outdated"
 
 If we don't listen for the `versionchange` event and don't close the old connection, then the second, new connection won't be made. The `openRequest` object will emit the `blocked` event instead of `success`. So the second tab won't work.
 
-Here's the code to correctly handle the parallel upgrade.
-
-It installs an `onversionchange` handler after the database is opened, that closes the old connection:
+Here's the code to correctly handle the parallel upgrade. It installs the `onversionchange` handler, that triggers if the current database connection becomes outdated (db version is updated elsewhere) and closes the connection.
 
 ```js
 let openRequest = indexedDB.open("store", 2);
@@ -164,14 +162,16 @@ openRequest.onblocked = function() {
 */!*
 ```
 
-Here we do two things:
+...In other words, here we do two things:
+
+1. The `db.onversionchange` listener informs us about a parallel update attempt, if the current database version becomes outdated.
+2. The `openRequest.onblocked` listener informs us about the opposite situation: there's a connection to an outdated version elsewhere, and it doesn't close, so the newer connection can't be made.
 
-1. Add `db.onversionchange` listener after a successful opening, to be informed about a parallel update attempt.
-2. Add `openRequest.onblocked` listener to handle the case when an old connection wasn't closed. This doesn't happen if we close it in `db.onversionchange`.
+We can handle things more gracefully in `db.onversionchange`, prompt the visitor to save the data before the connection is closed and so on. 
 
-There are other variants. For example, we can take the time to close things gracefully in `db.onversionchange`, and prompt the visitor to save the data before the connection is closed. The new updating connection will be blocked immediately after `db.onversionchange` has finished without closing, and we can ask the visitor in the new tab to close other tabs for the update.
+Or, an alternative approach would be to not close the database in `db.onversionchange`, but instead use the `onblocked` handler (in the new tab) to alert the visitor, tell him that the newer version can't be loaded until they close other tabs.
 
-These update collisions happen rarely, but we should at least have some handling for them, e.g. `onblocked` handler, so that our script doesn't surprise the user by dying silently.
+These update collisions happen rarely, but we should at least have some handling for them, at least `onblocked` handler, to prevent our script from dying silently.
 
 ## Object store
 
@@ -475,24 +475,29 @@ request.onerror = function(event) {
 };
 ```
 
-## Searching by keys
+## Searching
 
 There are two main types of search in an object store:
-1. By a key or a key range. That is: by `book.id` in our "books" storage.
-2. By another object field, e.g. `book.price`.
 
-First let's deal with the first type of search: by a key.
+1. By a key value or a key range. In our "books" storage that would be a value or range of values of `book.id`.
+2. By another object field, e.g. `book.price`. This required an additional data structure, named "index".
+
+### By key
 
-Searching methods support both exact keys and so-called "ranges" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) objects that specify an acceptable "key range".
+First let's deal with the first type of search: by key.
 
-Ranges are created using following calls:
+Searching methods support both exact key values and so-called "ranges of values" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) objects that specify an acceptable "key range".
+
+`IDBKeyRange` objects are created using following calls:
 
 - `IDBKeyRange.lowerBound(lower, [open])` means: `≥lower` (or `>lower` if `open` is true)
 - `IDBKeyRange.upperBound(upper, [open])` means: `≤upper` (or `<upper` if `open` is true)
 - `IDBKeyRange.bound(lower, upper, [lowerOpen], [upperOpen])` means: between `lower` and `upper`. If the open flags is true, the corresponding key is not included in the range.
 - `IDBKeyRange.only(key)` -- a range that consists of only one `key`, rarely used.
 
-Searching methods accept a `query` argument that can be either an exact key or a key range:
+We'll see practical examples of using them very soon.
+
+To perform the actual search, there are following methods. They accept a `query` argument that can be either an exact key or a key range:
 
 - `store.get(query)` -- search for the first value by a key or a range.
 - `store.getAll([query], [count])` -- search for all values, limit by `count` if given.
@@ -522,13 +527,12 @@ books.getAllKeys(IDBKeyRange.lowerBound('js', true))
 ```
 
 ```smart header="Object store is always sorted"
-Object store sorts values by key internally.
+An object store sorts values by key internally.
 
 So requests that return many values always return them in sorted by key order.
 ```
 
-
-## Searching by any field with an index
+### By a field using an index
 
 To search by other object fields, we need to create an additional data structure named "index".
 

From e01998baf8f85d9d6cef9f1add6c81b901f16d69 Mon Sep 17 00:00:00 2001
From: Ilya Kantor <iliakan@gmail.com>
Date: Sun, 14 Mar 2021 09:52:00 +0300
Subject: [PATCH 25/25] minor fixes

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

diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index e9a02e634..6fd513f43 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -160,7 +160,7 @@ There are two ways to do so:
     ```js run
     let num = 1.23456;
 
-    alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
+    alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
 2. The method [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to `n` digits after the point and returns a string representation of the result.