Merge pull request #1 from iliakan/master

sync with upsteam

1-js/01-getting-started/1-intro/article.md

@@ -30,7 +30,7 @@ Different engines have different "codenames", for example:
 
 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.
 
-```smart header="How engines work?"
+```smart header="How do engines work?"
 
 Engines are complicated. But the basics are easy.
 

1-js/02-first-steps/01-hello-world/article.md

@@ -47,7 +47,7 @@ The `<script>` tag has a few attributes that are rarely used nowadays, but we ca
 
  The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
 
- : The old standard HTML4 required a script to have a type. Usually it was `type="text/javascript"`. The modern HTML standard assumes this `type` by default. No attribute is required.
+ : The old standard HTML4 required a script to have a type. Usually it was `type="text/javascript"`. It's not required any more. Also, the modern standard totally changed the meaning of this attribute. Now it can be used for Javascript modules. But that's an advanced topic, but we'll talk about modules later in another part of the tutorial. 
 
  The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
   : This attribute was meant to show the language of the script. As of now, this attribute makes no sense, the language is JavaScript by default. No need to use it.
@@ -61,7 +61,7 @@ Comments before and after scripts.
     //--></script>
     ```
 
-    These comments were supposed to hide the code from an old browser that didn't know about a `<script>` tag. But all browsers born in the past 15+ years don't have any issues. We mention it here, because such comments serve as a sign. If you see that somewhere -- that code is probably really old and not worth looking into.
+    This trick isn't used in modern JavaScript. These comments were used to hide the JavaScript code from old browsers that didn't know about a `<script>` tag. Since browsers born in the last 15 years don't have this issue, this kind of comment can help you identify really old code.
 
 
 ## External scripts

1-js/02-first-steps/04-variables/article.md

@@ -247,7 +247,7 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // error, can't reassign the constant!
 ```
 
-When a programmer is sure that the variable should never change, he can use `const` to guarantee it, and also to clearly show that fact to everyone.
+When a programmer is sure that the variable should never change, they can use `const` to guarantee it, and also to clearly show that fact to everyone.
 
 
 ### Uppercase constants

1-js/02-first-steps/08-comparison/article.md

@@ -176,7 +176,7 @@ Yeah, mathematically that's strange. The last result states that "`null` is grea
 
 The reason is that an equality check `==` and comparisons `> < >= <=` work differently. Comparisons convert `null` to a number, hence treat it as `0`. That's why (3) `null >= 0` is true and (1) `null > 0` is false.
 
-On the other hand, the equality check `==` for `undefined` and `null` works by the rule, without any conversions. They equal each other and don't equal anything else. That's why (2) `null == 0` is false.
+On the other hand, the equality check `==` for `undefined` and `null` is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0` is false.
 
 ### An incomparable undefined
 

1-js/02-first-steps/11-logical-operators/article.md

@@ -230,14 +230,10 @@ When all values are truthy, the last value is returned:
 alert( 1 && 2 && 3 ); // 3, the last one
 ```
 
-````smart header="AND `&&` executes before OR `||`"
-The precedence of the AND `&&` operator is higher than OR `||`, so it executes before OR.
+````smart header="Precedence of AND `&&` is higher than OR `||`"
+The precedence of AND `&&` operator is higher than OR `||`.
 
-In the code below `1 && 0` is calculated first:
-
-```js run
-alert( 5 || 1 && 0 ); // 5
-```
+So the code `a && b || c && d` is essentially the same as if `&&` were in parentheses: `(a && b) || (c && d)`.
 ````
 
 Just like OR, the AND `&&` operator can sometimes replace `if`.
@@ -303,3 +299,5 @@ There's a little more verbose way to do the same thing -- a built-in `Boolean` f
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
+
+The precedence of NOT `!` is the highest of all bitwise operators, so it always executes first, before any `&&`, `||`.

1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Repeat until the input is correct
 
-Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask him to input again.
+Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
 
 The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line.
 

1-js/02-first-steps/16-javascript-specials/article.md

@@ -103,7 +103,7 @@ More in: <info:variables> and <info:types>.
 We're using a browser as a working environment, so basic UI functions will be:
 
 [`prompt(question[, default])`](mdn:api/Window/prompt)
-: Ask a `question`, and return either what the visitor entered or `null` if he pressed "cancel".
+: Ask a `question`, and return either what the visitor entered or `null` if they pressed "cancel".
 
 [`confirm(question)`](mdn:api/Window/confirm)
 : Ask a `question` and suggest to choose between Ok and Cancel. The choice is returned as `true/false`.
@@ -111,7 +111,7 @@ We're using a browser as a working environment, so basic UI functions will be:
 [`alert(message)`](mdn:api/Window/alert)
 : Output a `message`.
 
-All these functions are *modal*, they pause the code execution and prevent the visitor from interacting with the page until he answers.
+All these functions are *modal*, they pause the code execution and prevent the visitor from interacting with the page until they answer.
 
 For instance:
 

1-js/03-code-quality/03-comments/article.md

@@ -162,7 +162,7 @@ Any subtle features of the code? Where they are used?
 
 ## Summary
 
-An important sign of a good developer is comments: their presence and even their absense.
+An important sign of a good developer is comments: their presence and even their absence.
 
 Good comments allow us to maintain the code well, come back to it after a delay and use it more effectively.
 

1-js/03-code-quality/04-ninja-code/article.md

@@ -34,7 +34,7 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
 Cool, right? If you write like that, the developer who comes across this line and tries to understand what is the value of `i` is going to have a merry time. Then come to you, seeking for an answer.
 
-Tell him that shorter is always better. Initiate him into the paths of ninja.
+Tell them that shorter is always better. Initiate them into the paths of ninja.
 
 ## One-letter variables
 
@@ -45,11 +45,11 @@ completed.
 
 Another way to code faster is to use single-letter variable names everywhere. Like `a`, `b` or `c`.
 
-A short variable disappears in the code like a real ninja in the forest. No one will be able to find it using "search" of the editor. And even if someone does, he won't be able to "decipher" what the name `a` or `b` means.
+A short variable disappears in the code like a real ninja in the forest. No one will be able to find it using "search" of the editor. And even if someone does, they won't be able to "decipher" what the name `a` or `b` means.
 
 ...But there's an exception. A real ninja will never use `i` as the counter in a `"for"` loop. Anywhere, but not here. Look around, there are many more exotic letters. For instance, `x` or `y`.
 
-An exotic variable as a loop counter is especially cool if the loop body takes 1-2 pages (make it longer if you can). Then if someone looks deep inside the loop, he won't be able to quickly figure out that the variable named `x` is the loop counter.
+An exotic variable as a loop counter is especially cool if the loop body takes 1-2 pages (make it longer if you can). Then if someone looks deep inside the loop, they won't be able to quickly figure out that the variable named `x` is the loop counter.
 
 ## Use abbreviations
 
@@ -153,7 +153,7 @@ function ninjaFunction(elem) {
 }
 ```
 
-A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code he will find out that he's working with a clone!
+A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code they will find out that he's working with a clone!
 
 Deadly effective even against an experienced ninja. Seen in code regularly.
 
@@ -204,7 +204,7 @@ There are functions that look like they don't change anything. Like `isReady()`,
 
 **A really beautiful trick is to add a "useful" action to them, besides the main task.**
 
-The expression of dazed surprise on the face of your colleague when he sees a function named `is..`, `check..` or `find...` changing something -- will definitely broaden your boundaries of reason.
+The expression of dazed surprise on the face of your colleague when they see a function named `is..`, `check..` or `find...` changing something -- will definitely broaden your boundaries of reason.
 
 **Another way to surprise is to return a non-standard result.**
 
@@ -228,7 +228,7 @@ Additional actions should not be obvious from the function name. A true ninja co
 
 **Joining several actions into one protects your code from reuse.**
 
-Imagine, another developer wants only to check the email, and not output any message. Your function  `validateEmail(email)` that does both will not suit him. So he won't break your meditation by asking anything about it.
+Imagine, another developer wants only to check the email, and not output any message. Your function  `validateEmail(email)` that does both will not suit them. So they won't break your meditation by asking anything about it.
 
 ## Summary
 

1-js/03-code-quality/06-polyfills/article.md

@@ -19,7 +19,7 @@ Here Babel comes to the rescue.
 
 Actually, there are two parts in Babel:
 
-1. First, the transpiler program, which rewrites the code. The developer runs it on his own computer. It rewrites the code into the older standard. And then the code is delivered to the website for users. Modern project build system like [webpack](http://webpack.github.io/) or [brunch](http://brunch.io/) provide means to run transpiler automatically on every code change, so that doesn't involve any time loss from our side.
+1. First, the transpiler program, which rewrites the code. The developer runs it on their own computer. It rewrites the code into the older standard. And then the code is delivered to the website for users. Modern project build system like [webpack](http://webpack.github.io/) or [brunch](http://brunch.io/) provide means to run transpiler automatically on every code change, so that doesn't involve any time loss from our side.
 
 2. Second, the polyfill.
 

1-js/04-object-basics/01-object/article.md

@@ -224,7 +224,7 @@ That can become a source of bugs and even vulnerabilies if we intent to store ar
 
 In that case the visitor may choose "__proto__" as the key, and the assignment logic will be ruined (as shown above).
 
-There is a way to make objects treat `__proto__` as a regular property, which we'll cover later, but first we need to know more about objects. 
+There is a way to make objects treat `__proto__` as a regular property, which we'll cover later, but first we need to know more about objects.
 There's also another data structure [Map](info:map-set-weakmap-weakset), that we'll learn in the chapter <info:map-set-weakmap-weakset>, which supports arbitrary keys.
 ````
 
@@ -701,7 +701,7 @@ alert(clone.sizes.width); // 51, see the result from the other one
 
 To fix that, we should use the cloning loop that examines each value of `user[key]` and, if it's an object, then replicate its structure as well. That is called a "deep cloning".
 
-There's a standard algorithm for deep cloning that handles the case above and more complex cases, called the [Structured cloning algorithm](https://w3c.github.io/html/infrastructure.html#internal-structured-cloning-algorithm). In order not to reinvent the wheel, we can use a working implementation of it from the JavaScript library [lodash](https://lodash.com), the method is called [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+There's a standard algorithm for deep cloning that handles the case above and more complex cases, called the [Structured cloning algorithm](http://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data). In order not to reinvent the wheel, we can use a working implementation of it from the JavaScript library [lodash](https://lodash.com), the method is called [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
 
 
 

1-js/04-object-basics/04-object-methods/article.md

@@ -312,7 +312,7 @@ The result of a property access `user.hi` is not a function, but a value of Refe
 (user, "hi", true)
 ```
 
-When parentheses `()` are called on the Reference Type, they receive the full information about the object and it's method, and can set the right `this` (`=user` in this case).
+When parentheses `()` are called on the Reference Type, they receive the full information about the object and its method, and can set the right `this` (`=user` in this case).
 
 Any other operation like assignment `hi = user.hi` discards the reference type as a whole, takes the value of `user.hi` (a function) and passes it on. So any further operation "loses" `this`.
 

1-js/04-object-basics/06-constructor-new/article.md

@@ -85,6 +85,10 @@ The constructor can't be called again, because it is not saved anywhere, just cr
 
 ## Dual-syntax constructors: new.target
 
+```smart header="Advanced stuff"
+The syntax from this section is rarely used, skip it unless you want to know everything.
+```
+
 Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property.
 
 It is empty for regular calls and equals the function if called with `new`:
@@ -94,14 +98,18 @@ function User() {
   alert(new.target);
 }
 
-// without new:
+// without "new":
+*!*
 User(); // undefined
+*/!*
 
-// with new:
+// with "new":
+*!*
 new User(); // function User { ... }
+*/!*
 ```
 
-That can be used to allow both `new` and regular syntax to work the same:
+That can be used to allow both `new` and regular calls to work the same. That is, create the same object:
 
 ```js run
 function User(name) {
@@ -116,7 +124,9 @@ let john = User("John"); // redirects call to new User
 alert(john.name); // John
 ```
 
-This approach is sometimes used in libraries to make the syntax more flexible. Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created, that's a good thing.
+This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+
+Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
 
 ## Return from constructors
 

1-js/05-data-types/01-primitives-methods/article.md

@@ -2,7 +2,7 @@
 
 JavaScript allows us to work with primitives (strings, numbers etc) as if they were objects.
 
-They also provide methods to call and such. We will study those soon, but first we'll see how it works, because, of course, primitives are not objects (and here we will make it even more clear).
+They also provide methods to call as such. We will study those soon, but first we'll see how it works, because, of course, primitives are not objects (and here we will make it even more clear).
 
 Let's look at the key distinction between primitives and objects.
 

1-js/05-data-types/02-number/article.md

@@ -201,7 +201,7 @@ Strange! What is it then if not `0.3`?
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
-Ouch! There are more consequences than an incorrect comparison here. Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into his chart. The order total will be `$0.30000000000000004`. That would surprise anyone.
+Ouch! There are more consequences than an incorrect comparison here. Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into their chart. The order total will be `$0.30000000000000004`. That would surprise anyone.
 
 But why does this happen?
 

1-js/05-data-types/03-string/article.md

@@ -451,7 +451,7 @@ Let's recap these methods to avoid any confusion:
 ```smart header="Which one to choose?"
 All of them can do the job. Formally, `substr` has a minor drawback: it is described not in the core JavaScript specification, but in Annex B, which covers browser-only features that exist mainly for historical reasons. So, non-browser environments may fail to support it. But in practice it works everywhere.
 
-The author finds himself using `slice` almost all the time.
+The author finds themself using `slice` almost all the time.
 ```
 
 ## Comparing strings

1-js/05-data-types/04-array/6-calculator-extendable/task.md

@@ -17,7 +17,7 @@ The task consists of two parts.
 
     alert( calc.calculate("3 + 7") ); // 10
     ```
-2. Then add the method `addOperator(name, func)` that teaches the calculator a new operation. It takes the operator `name` and the two-argument function `func(a,b)` that implements it.
+2. Then add the method `addMethod(name, func)` that teaches the calculator a new operation. It takes the operator `name` and the two-argument function `func(a,b)` that implements it.
 
     For instance, let's add the multiplication `*`, division `/` and power `**`:
 

1-js/05-data-types/04-array/article.md

@@ -369,7 +369,7 @@ It's rarely used, because square brackets `[]` are shorter. Also there's a trick
 
 If `new Array` is called with a single argument which is a number, then it creates an array *without items, but with the given length*.
 
-Let's see how one can shoot himself in the foot:
+Let's see how one can shoot themself in the foot:
 
 ```js run
 let arr = new Array(2); // will it create an array of [2] ?

1-js/05-data-types/05-array-methods/article.md

@@ -417,7 +417,7 @@ alert(arr);  // *!*1, 2, 15*/!*
 ````
 
 ````smart header="Arrow functions for the best"
-Remember [arrow functions](info:function-expression#arrow-functions)? We can use them here for neater sorting:
+Remember [arrow functions](info:function-expressions-arrows#arrow-functions)? We can use them here for neater sorting:
 
 ```js
 arr.sort( (a, b) => a - b );

1-js/05-data-types/07-map-set-weakmap-weakset/article.md

@@ -47,7 +47,7 @@ For instance:
 ```js run
 let john = { name: "John" };
 
-// for every user, let's store his visits count
+// for every user, let's store their visits count
 let visitsCountMap = new Map();
 
 // john is the key for the map
@@ -332,7 +332,7 @@ That's useful for situations when we have a main storage for the objects somewhe
 
 Let's look at an example.
 
-For instance, we have code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don't want to store his visit count anymore.
+For instance, we have code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don't want to store their visit count anymore.
 
 One way would be to keep track of leaving users and clean up the storage manually:
 

1-js/06-advanced-functions/03-closure/article.md

@@ -175,7 +175,7 @@ The execution flow of the code above:
 
 1. The global Lexical Environment has `name: "John"`.
 2. At the line `(*)` the global variable is changed, now it has `name: "Pete"`.
-3. When the function `say()`, is executed and takes `name` from outside. Here that's from the global Lexical Environment where it's already `"Pete"`.
+3. When the function `sayHi()`, is executed and takes `name` from outside. Here that's from the global Lexical Environment where it's already `"Pete"`.
 
 
 ```smart header="One call -- one Lexical Environment"

1-js/06-advanced-functions/08-settimeout-setinterval/article.md

@@ -319,7 +319,7 @@ We do a part of the job `(*)`:
 2. Second run: `i=1000001..2000000`.
 3. ...and so on, the `while` checks if `i` is evenly divided by `1000000`.
 
-Then the next call is scheduled in `(*)` if we're not done yet.
+Then the next call is scheduled in `(**)` if we're not done yet.
 
 Pauses between `count` executions provide just enough "breath" for the JavaScript engine to do something else, to react to other user actions.
 

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md

@@ -22,7 +22,7 @@ So we'll assign `throttle(update, 100)` as the function to run on each mouse mov
 
 Visually, it will look like this:
 
-1. For the first mouse movement the decorated variant passes the call to `update`. That's important, the user sees our reaction to his move immediately.
+1. For the first mouse movement the decorated variant passes the call to `update`. That's important, the user sees our reaction to their move immediately.
 2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
 3. At the end of `100ms` -- one more `update` happens with the last coordinates. 
 4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` runs with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.

1-js/07-object-oriented-programming/01-property-descriptors/article.md

@@ -3,7 +3,7 @@
 
 As we know, objects can store properties.
 
-Till now, a property was a simple "key-value" pair to us. But an object property is actually more complex and tunable thing.
+Till now, a property was a simple "key-value" pair to us. But an object property is actually a more complex and tunable thing.
 
 ## Property flags
 
@@ -118,7 +118,7 @@ user.name = "Pete"; // Error: Cannot assign to read only property 'name'...
 */!*
 ```
 
-Now no one can change the name of our user, unless he applies his own `defineProperty` to override ours.
+Now no one can change the name of our user, unless they apply their own `defineProperty` to override ours.
 
 Here's the same operation, but for the case when a property doesn't exist:
 

1-js/07-object-oriented-programming/03-prototype-inheritance/4-hamster-proto/solution.md

@@ -44,7 +44,7 @@ alert( lazy.stomach ); // <nothing>
 
 Now all works fine, because `this.stomach=` does not perform a lookup of `stomach`. The value is written directly into `this` object.
 
-Also we can totally evade the problem by making sure that each hamster has his own stomach:
+Also we can totally evade the problem by making sure that each hamster has their own stomach:
 
 ```js run
 let hamster = {

1-js/08-error-handling/1-try-catch/article.md

@@ -194,7 +194,7 @@ You can find more detailed information about JSON in the <info:json> chapter.
 
 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 he opens developer console). And people really don't like when something "just dies" without any error message.
+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:
 
@@ -575,7 +575,7 @@ 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 something else terrible.
 
-Is there a way to react on such occurrences? We may want to log the error, show something to the user (normally he doesn't see error messages) etc.
+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.
 
 There is none in the specification, but environments usually provide it, because it's really useful. For instance, Node.JS has [process.on('uncaughtException')](https://nodejs.org/api/process.html#process_event_uncaughtexception) for that. And in the browser we can assign a function to special [window.onerror](mdn:api/GlobalEventHandlers/onerror) property. It will run in case of an uncaught error.
 

2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md

@@ -25,7 +25,7 @@ let form = document.getElementsByName('search')[0]
 document.querySelector('form[name="search"]')
 
 // 5. The first input in that form.
-form.getElementsByTagName('input')
+form.getElementsByTagName('input')[0]
 // or
 form.querySelector('input')
 

2-ui/1-document/11-coordinates/head.html

@@ -1,7 +1,11 @@
 <script>
 document.addEventListener('DOMContentLoaded', function() {
 
-  document.getElementById('coords-show-mark').onclick = function() {
+let elem = document.getElementById('coords-show-mark');
+
+// no elem in ebook mode
+if (elem) {
+  elem.onclick = function() {
     let elem = document.getElementById("coords-show-mark");
 
     function createMessageUnder(elem, text) {
@@ -21,6 +25,7 @@ document.addEventListener('DOMContentLoaded', function() {
     document.body.append(message);
     setTimeout(() => message.remove(), 5000);
   }
+}
 
 });
 

2-ui/2-events/04-default-browser-action/2-catch-link-navigation/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Catch links in the element
 
-Make all links inside the element with `id="contents"` ask the user if he really wants to leave. And if he doesn't then don't follow.
+Make all links inside the element with `id="contents"` ask the user if they really want to leave. And if they don't then don't follow.
 
 Like this:
 

2-ui/3-event-details/1-mouse-events-basics/article.md

@@ -175,7 +175,7 @@ Now if you double-click on "Unselectable", it doesn't get selected. Seems to wor
 
 ...But there is a potential problem! The text became truly unselectable. Even if a user starts the selection from "Before" and ends with "After", the selection skips "Unselectable" part. Do we really want to make our text unselectable?
 
-Most of time, we don't. A user may have valid reasons to select the text, for copying or other needs. That may be inconvenient if we don't allow him to do it. So this solution is not that good.
+Most of time, we don't. A user may have valid reasons to select the text, for copying or other needs. That may be inconvenient if we don't allow them to do it. So this solution is not that good.
 
 What we want is to prevent the selection on double-click, that's it.
 

2-ui/3-event-details/10-onload-ondomcontentloaded/article.md

@@ -10,7 +10,7 @@ Each event may be useful:
 
 - `DOMContentLoaded` event -- DOM is ready, so the handler can lookup DOM nodes, initialize the interface.
 - `load` event -- additional resources are loaded, we can get image sizes (if not specified in HTML/CSS) etc.
-- `beforeunload/unload` event -- the user is leaving: we can check if the user saved the changes and  ask him whether he really wants to leave.
+- `beforeunload/unload` event -- the user is leaving: we can check if the user saved the changes and ask them whether they really want to leave.
 
 Let's explore the details of these events.
 
@@ -43,7 +43,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, not waits for the page load. So `alert` shows zero sizes.
+In the example the `DOMContentLoaded` handler runs when the document is loaded and does not wait for the image to load. So `alert` shows zero sizes.
 
 At the first sight `DOMContentLoaded` event is very simple. The DOM tree is ready -- here's the event. But there are few peculiarities.
 

2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Write a function that shows a tooltip over an element only if the visitor moves the mouse *over it*, but not *through it*.
 
-In other words, if the visitor moves the mouse on the element and stopped -- show the tooltip. And if he just moved the mouse through fast, then no need, who wants extra blinking?
+In other words, if the visitor moves the mouse on the element and stopped -- show the tooltip. And if they just moved the mouse through fast, then no need, who wants extra blinking?
 
 Technically, we can measure the mouse speed over the element, and if it's slow then we assume that it comes "over the element" and show the tooltip, if it's fast -- then we ignore it.
 

2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md

@@ -169,7 +169,7 @@ Here's the full example with all details:
 
 [codetabs height=380 src="mouseenter-mouseleave-delegation-2"]
 
-Try to move the cursor in and out of table cells and inside them. Fast or slow -- doesn't better. Only `<td>` as a whole is highlighted unlike the example before.
+Try to move the cursor in and out of table cells and inside them. Fast or slow -- doesn't matter. Only `<td>` as a whole is highlighted unlike the example before.
 ```
 
 

2-ui/3-event-details/5-keyboard-events/2-check-sync-keydown/solution.view/index.html

@@ -23,7 +23,7 @@
         // JavaScript does not get the "keyup" event
         // and pressed set will keep assuming that the key is pressed
         // so, to evade "sticky" keys, we reset the status
-        // if the user wants to run the hotkey again - let him press all keys again
+        // if the user wants to run the hotkey again - let them press all keys again
         pressed.clear();
 
         func();

2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md

@@ -4,7 +4,7 @@ importance: 4
 
 # Load visible images
 
-Let's say we have a slow-speed client and want to save his mobile traffic.
+Let's say we have a slow-speed client and want to save their mobile traffic.
 
 For that purpose we decide not to show images immediately, but rather replace them with placeholders, like this:
 

2-ui/4-forms-controls/1-form-elements/1-add-select-option/solution.md

@@ -8,12 +8,12 @@ The solution, step by step:
 
 <script>
   // 1)
-  let selectedOption = genres.options[select.selectedIndex];
+  let selectedOption = genres.options[genres.selectedIndex];
   alert( selectedOption.value );
 
   // 2)
-  let newOption = new Option("classic", "Classic");
-  select.append(newOption);
+  let newOption = new Option("Classic", "classic");
+  genres.append(newOption);
 
   // 3)
   newOption.selected = true;

2-ui/4-forms-controls/4-forms-submit/1-modal-dialog/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Create a function `showPrompt(html, callback)` that shows a form with the message `html`, an input field and buttons `OK/CANCEL`.
 
-- A user should type something into a text field and press `key:Enter` or the OK button, then `callback(value)` is called with the value he entered.
+- A user should type something into a text field and press `key:Enter` or the OK button, then `callback(value)` is called with the value they entered.
 - Otherwise if the user presses `key:Esc` or CANCEL, then `callback(null)` is called.
 
 In both cases that ends the input process and removes the form.

4-frames-and-windows/01-popup-windows/article.md

@@ -176,7 +176,7 @@ Still, there are some things that can be done.
 For instance:
 
 - When we open a popup, it's might be a good idea to run a `newWindow.focus()` on it. Just in case, for some OS/browser combinations it ensures that the user is in the new window now.
-- If we want to track when a visitor actually uses our web-app, we can track `window.onfocus/onblur`. That allows us to suspend/resume in-page activities, animations etc. But please note that the `blur` event means that the visitor switched out from the window, but he still may observe it. The window is in the background, but still may be visible.
+- If we want to track when a visitor actually uses our web-app, we can track `window.onfocus/onblur`. That allows us to suspend/resume in-page activities, animations etc. But please note that the `blur` event means that the visitor switched out from the window, but they still may observe it. The window is in the background, but still may be visible.
 
 ## Summary   
 

4-frames-and-windows/06-clickjacking/article.md

@@ -62,7 +62,7 @@ All we need to attack -- is to position the `<iframe>` on the evil page in such
 ```smart header="Clickjacking is for clicks, not for keyboard"
 The attack only affects mouse actions.
 
-Technically, if we have a text field to hack, then we can position an iframe in such a way that text fields overlap each other. So when a visitor tries to focus on the input he sees on the page, he actually focuses on the input inside the iframe.
+Technically, if we have a text field to hack, then we can position an iframe in such a way that text fields overlap each other. So when a visitor tries to focus on the input they see on the page, they actually focus on the input inside the iframe.
 
 But then there's a problem. Everything that the visitor types will be hidden, because the iframe is not visible.
 
@@ -89,7 +89,7 @@ This not a reliable defence, because there are many ways to hack around it. Let'
 
 We can block the transition caused by changing `top.location` in the [beforeunload](info:onload-ondomcontentloaded#window.onbeforeunload) event.
 
-The top page (belonging to the hacker) sets a handler to it, and when the `iframe` tries to change `top.location` the visitor gets a message asking him whether he wants to leave.
+The top page (belonging to the hacker) sets a handler to it, and when the `iframe` tries to change `top.location` the visitor gets a message asking them whether they want to leave.
 
 Like this:
 ```js
@@ -99,7 +99,7 @@ window.onbeforeunload = function() {
 };
 ```
 
-In most cases the visitor would answer negatively, because he doesn't know about the iframe, all he can see is the top page, leading him to think there is no reason to leave. So `top.location` won't change!
+In most cases the visitor would answer negatively because they don't know about the iframe - all they can see is the top page, leading them to think there is no reason to leave. So `top.location` won't change!
 
 In action:
 
@@ -188,9 +188,9 @@ The demo:
 
 Clickjacking is a way to "trick" users into clicking on a malicious site without even knowing what's happening. That's dangerous if there are important click-activated actions.
 
-A hacker can post a link to his evil page in a message, or lure visitors to his page by some other means. There are many variations.
+A hacker can post a link to their evil page in a message, or lure visitors to their page by some other means. There are many variations.
 
-From one perspective -- the attack is "not deep": all a hacker is doing is intercepting a single click. But from another perspective, if the hacker knows that after the click another control will appear, then he may use cunning messages to coerce the user into clicking on them as well.
+From one perspective -- the attack is "not deep": all a hacker is doing is intercepting a single click. But from another perspective, if the hacker knows that after the click another control will appear, then they may use cunning messages to coerce the user into clicking on them as well.
 
 The attack is quite dangerous, because when we engineer the UI we usually don't anticipate that a hacker may click on behalf of the visitor. So vulnerabilities can be found in totally unexpected places.
 

4-frames-and-windows/06-clickjacking/top-location.view/index.html

@@ -31,9 +31,9 @@
 
 <body>
 
-  <p>After a click on the button the visitor gets a "strange" question about whether he wants to leave.</p>
+  <p>After a click on the button the visitor gets a "strange" question about whether they want to leave.</p>
 
-  <p>Probably he would respond "No", and the iframe protection is hacked.</p>
+  <p>Probably they would respond "No", and the iframe protection is hacked.</p>
 
   <button onclick="attack()">Add a "protected" iframe</button>
 

5-regular-expressions/02-regexp-methods/article.md

@@ -234,7 +234,7 @@ Using a function gives us the ultimate replacement power, because it gets all th
 
 Let's move on to the methods of `RegExp` class, that are callable on regexps themselves.
 
-The `test` method looks for any match and returns `true/false` whether he found it.
+The `test` method looks for any match and returns `true/false` whether they found it.
 
 So it's basically the same as `str.search(reg) != -1`, for instance:
 

6-async/02-promise-basics/article.md

@@ -123,7 +123,7 @@ The properties `state` and `result` of the Promise object are internal. We can't
 
 ## Consumers: "then" and "catch"
 
-A Promise object serves as a link between the executor (the "producing code" or "singer) and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using the methods `.then` and `.catch`.
+A Promise object serves as a link between the executor (the "producing code" or "singer") and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using the methods `.then` and `.catch`.
 
 The syntax of `.then` is:
 

6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html

@@ -21,7 +21,7 @@
         alert(responses[0].status); // 200
         alert(responses[1].status); // 200
         alert(responses[2]); // TypeError: failed to fetch (text may vary)
-      ));
+      });
   </script>
 
 </body>

6-async/04-promise-api/01-promise-errors-as-results/task.md

@@ -17,7 +17,7 @@ Promise.all(urls.map(url => fetch(url)))
     for(let response of responses) {
       alert(`${response.url}: ${response.status}`);
     }
-  ));
+  });
 ```
 
 The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we loose results of all the other requests.

6-async/05-async-await/article.md

@@ -1,6 +1,6 @@
 # Async/await
 
-There's a special syntax to work with promises in a more comfort fashion, called "async/await". It's surprisingly easy to understand and use.
+There's a special syntax to work with promises in a more comfortable fashion, called "async/await". It's surprisingly easy to understand and use.
 
 ## Async functions
 

README.md

@@ -1,4 +1,3 @@
-
 # The JavaScript Tutorial
 
 This repository hosts the content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
@@ -7,19 +6,19 @@ This repository hosts the content of the Modern JavaScript Tutorial, published a
 
 (In alphabetical order):
 
-| Language | Github | Translation leads | Published |
-|----------|--------|-------------------|-----------|
-| Chinese | https://github.com/xitu/javascript-tutorial-zh | @leviding | – |
-| French | https://github.com/SugoiNelson/javascript-tutorial-fr | @SugoiNelson | - |
-| German | https://github.com/MartinEls/javascript-tutorial-de | @MartilEls | - |
-| Japanese | https://github.com/KenjiI/javascript-tutorial-ja | @KenjiI | - |
-| Russian | https://github.com/iliakan/javascript-tutorial-ru | @iliakan | https://learn.javascript.ru | 
-| Turkish | https://github.com/sahinyanlik/javascript-tutorial-tr | @sahinyanlik | - |
-| Uzbek | https://github.com/aruzikulov/javascript-tutorial-uz | @aruzikulov | - |
+| Language | Github | Translation leads | Translated (%) | Published |
+|----------|--------|-------------------|-----------------|-----------|
+| Chinese | https://github.com/xitu/javascript-tutorial-zh | @leviding | ![](http://translate-hook.javascript.info/stats/zh.svg) | - |
+| Danish | https://github.com/ockley/javascript-tutorial-da | @ockey | ![](http://translate-hook.javascript.info/stats/da.svg) | - |
+| German | https://github.com/MartinEls/javascript-tutorial-de | @MartilEls | ![](http://translate-hook.javascript.info/stats/de.svg) | - |
+| Japanese | https://github.com/KenjiI/javascript-tutorial-ja | @KenjiI | ![](http://translate-hook.javascript.info/stats/ja.svg) | - |
+| Persian | https://github.com/Goudarz/javascript-tutorial-fa | @Goudarz | ![](http://translate-hook.javascript.info/stats/fa.svg) | - |
+| Russian | https://github.com/iliakan/javascript-tutorial-ru | @iliakan |  | https://learn.javascript.ru |
+| Turkish | https://github.com/sahinyanlik/javascript-tutorial-tr | @sahinyanlik | ![](http://translate-hook.javascript.info/stats/tr.svg) | - |
 
 If you'd like to translate it into your language, please clone the repository, change its name to `javascript-tutorial-...` (by the language) and [create an issue](https://github.com/iliakan/javascript-tutoria-en/issues/new) for me to add you to the list.
 
-The server to run the tutorial locally is at <https://github.com/iliakan/javascript-tutorial-server/>.
+You can edit the text in any editor (markdown-like syntax). The server to run the tutorial locally and see how it looks is at <https://github.com/iliakan/javascript-tutorial-server>.  
 
 ## Structure
 
@@ -34,5 +33,3 @@ The type of the material is defined by the file inside the folder:
   - `task.md` stands for a task (solution must be provided in `solution.md` file aswell)
 
 Each of these files starts from the `# Main header`.
-
-Assets required for the material reside in the same folder.