merging all conflicts

Author: iliakan

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

@@ -65,7 +65,11 @@ Engines നല്ല ബുദ്ധിമുട്ടുള്ള ഒരു വ
 
 - ഒരു വെബ്‌പേജിലെ ജാവസ്ക്രിപ്റ്റന് ഹാർഡ് ഡിസ്കിൽ നിയന്ത്രണമില്ലാത്ത ഫയലുകൾ വായിക്കാനോ എഴുതാനോ കഴിയില്ല, അവ പകർത്താനോ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാനോ പാടില്ല. ഇതിന് OS ഫംഗ്ഷനുകളിലേക്ക് നേരിട്ട് പ്രവേശനമില്ല.
 
+<<<<<<< HEAD
     ആധുനിക ബ്രൌസർ‌ ഫയലുകളുമായി പ്രവർ‌ത്തിക്കാൻ‌ ഇത് അനുവദിക്കുന്നു, പക്ഷേ ആക്‌സസ് പരിമിതമാണ് ,കൂടാതെ ഉപയോക്താവ് ഒരു ബ്രൗസർ വിൻ‌ഡോയിലേക്ക് ഒരു ഫയൽ‌ ഡ്രോപ്പ് ചെയ്യുകയോ അല്ലെങ്കിൽ‌ `<input>` ടാഗ് വഴി തിരഞ്ഞെടുക്കുകയോ പോലുള്ള ചില പ്രവർ‌ത്തനങ്ങൾ‌ നടത്തുകയാണെങ്കിൽ‌ മാത്രം.
+=======
+JavaScript's abilities in the browser are limited for the sake of a user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
+>>>>>>> 6989312841d843f2350803ab552d9082437be569
 
     ക്യാമറ / മൈക്രോഫോൺ, മറ്റ് ഉപകരണങ്ങൾ എന്നിവയുമായി സംവദിക്കാനുള്ള മാർഗങ്ങളുണ്ട്, പക്ഷേ അവയ്‌ക്ക് ഉപയോക്താവിന്റെ വ്യക്തമായ അനുമതി ആവശ്യമാണ്. അതിനാൽ ഒരു ജാവാസ്ക്രിപ്റ്റ്  പേജ് ഒരു വെബ് ക്യാമറയെ തന്ത്രപൂർവ്വം ഓപ്പൺ ചെയ്യാൻ ചുറ്റുപാടുകൾ നിരീക്ഷിക്കുകയും വിവരങ്ങൾ [NSA](https://en.wikipedia.org/wiki/National_Security_Agency) ലോട്ടു അയയ്ക്കുകയോ ചെയ്യരുത്.
 - വ്യത്യസ്ത ടാബുകൾ / വിൻഡോകൾ സാധാരണയായി പരസ്പരo ബന്ധം കാണില്ല. ചിലപ്പോൾ അവ അങ്ങനെ ചെയ്യാം, ഉദാഹരണത്തിന് ഒരു വിൻഡോ മറ്റൊരു വിൻഡോ തുറക്കാൻ ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിക്കുമ്പോൾ. ഈ സാഹചര്യത്തിൽ പോലും, വ്യത്യസ്ത സൈറ്റുകളിൽ നിന്ന് (മറ്റൊരു ഡൊമെയ്ൻ, പ്രോട്ടോക്കോൾ അല്ലെങ്കിൽ പോർട്ടിൽ നിന്ന്) വന്നാൽ ഒരു പേജിൽ നിന്നുള്ള ജാവാസ്ക്രിപ്റ്റ് മറ്റൊന്നിലേക്ക് പ്രവേശിക്കാനിടയില്ല.
@@ -94,7 +98,16 @@ Engines നല്ല ബുദ്ധിമുട്ടുള്ള ഒരു വ
 
 സെർവറുകൾ, മൊബൈൽ ആപ്ലിക്കേഷനുകൾ തുടങ്ങിയവ ഉണ്ടാക്കാനും ജാവാസ്ക്രിപ്റ്റ് അനുവദിക്കുന്നു.
 
+<<<<<<< HEAD
 ## ജാവാസ്ക്രിപ്റ്റിന് മുകളിലുള്ള ഭാഷകൾ
+=======
+```compare
++ Full integration with HTML/CSS.
++ Simple things are done simply.
++ Supported by all major browsers and enabled by default.
+```
+JavaScript is the only browser technology that combines these three things.
+>>>>>>> 6989312841d843f2350803ab552d9082437be569
 
 ജാവാസ്ക്രിപ്റ്റിന്റെ syntax എല്ലാവരുടെയും ആവശ്യങ്ങൾക്ക് അനുയോജ്യമല്ല. വ്യത്യസ്ത ആളുകൾക്ക് വ്യത്യസ്ത സവിശേഷതകൾ വേണം.
 
@@ -121,3 +134,9 @@ Engines നല്ല ബുദ്ധിമുട്ടുള്ള ഒരു വ
 - ജാവാസ്ക്രിപ്റ്റിലേക്ക് "കൈമാറ്റം ചെയ്യപ്പെടുകയും" ചില സവിശേഷതകൾ നൽകുകയും ചെയ്യുന്ന നിരവധി ഭാഷകളുണ്ട്. ജാവാസ്ക്രിപ്റ്റ്നെ നന്നായി അറിഞ്ഞതിനു ശേഷം, അവ പരിശോധിക്കുന്നത് നല്ലതായിരിക്കും.
 
 
+<<<<<<< HEAD
+=======
+- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
+- Today, JavaScript has a unique position as the most widely-adopted browser language, fully integrated with HTML/CSS.
+- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+>>>>>>> 6989312841d843f2350803ab552d9082437be569

1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/test.js

@@ -23,7 +23,7 @@ describe("byField", function(){
       { name: "John", age: 20, surname: "Johnson"},
     ];
     let ageSortedAnswer = users.sort(byField("age"));
-    assert.deepEqual(ageSortedKey, ageSortedKey);
+    assert.deepEqual(ageSortedKey, ageSortedAnswer);
   });
 
   it("sorts users by surname", function(){

1-js/06-advanced-functions/10-bind/article.md

@@ -187,8 +187,8 @@ let user = {
 
 let say = user.say.bind(user);
 
-say("Hello"); // Hello, John ("Hello" argument is passed to say)
-say("Bye"); // Bye, John ("Bye" is passed to say)
+say("Hello"); // Hello, John! ("Hello" argument is passed to say)
+say("Bye"); // Bye, John! ("Bye" is passed to say)
 ```
 
 ````smart header="Convenience method: `bindAll`"

1-js/09-classes/06-instanceof/article.md

@@ -93,7 +93,7 @@ The algorithm of `obj instanceof Class` works roughly as follows:
     alert(rabbit instanceof Animal); // true
     */!*
 
-    // rabbit.__proto__ === Rabbit.prototype
+    // rabbit.__proto__ === Animal.prototype (no match)
     *!*
     // rabbit.__proto__.__proto__ === Animal.prototype (match!)
     */!*

1-js/11-async/03-promise-chaining/article.md

@@ -37,7 +37,7 @@ The idea is that the result is passed through the chain of `.then` handlers.
 Here the flow is:
 1. The initial promise resolves in 1 second `(*)`,
 2. Then the `.then` handler is called `(**)`, which in turn creates a new promise (resolved with `2` value).
-3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes the next handler.
+3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes it to the next handler.
 4. ...and so on.
 
 As the result is passed along the chain of handlers, we can see a sequence of `alert` calls: `1` -> `2` -> `4`.

1-js/11-async/08-async-await/article.md

@@ -303,7 +303,7 @@ The `async` keyword before a function has two effects:
 
 The `await` keyword before a promise makes JavaScript wait until that promise settles, and then:
 
-1. If it's an error, the exception is generated — same as if `throw error` were called at that very place.
+1. If it's an error, an exception is generated — same as if `throw error` were called at that very place.
 2. Otherwise, it returns the result.
 
 Together they provide a great framework to write asynchronous code that is easy to both read and write.

1-js/13-modules/01-modules-intro/article.md

@@ -261,7 +261,7 @@ Compare it to non-module scripts, where `this` is a global object:
 
 There are also several browser-specific differences of scripts with `type="module"` compared to regular ones.
 
-You may want skip this section for now if you're reading for the first time, or if you don't use JavaScript in a browser.
+You may want to skip this section for now if you're reading for the first time, or if you don't use JavaScript in a browser.
 
 ### Module scripts are deferred
 

2-ui/1-document/05-basic-dom-node-properties/article.md

@@ -25,7 +25,9 @@ The classes are:
     - [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement) -- the class for `<input>` elements,
     - [HTMLBodyElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlbodyelement) -- the class for `<body>` elements,
     - [HTMLAnchorElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlanchorelement) -- the class for `<a>` elements,
-    - ...and so on, each tag has its own class that may provide specific properties and methods.
+    - ...and so on.
+
+There are many other tags with their own classes that may specific properties and methods, while some elements, such as `<span>`, `<section>`, `<article>` do not have any specific properties, so they are instances of `HTMLElement` class.
 
 So, the full set of properties and methods of a given node comes as the result of the inheritance.
 
@@ -128,7 +130,7 @@ For instance:
 
 ```html run
 <body>
-  <script>  
+  <script>
   let elem = document.body;
 
   // let's examine what it is?

2-ui/1-document/09-size-and-scroll/article.md

@@ -116,7 +116,7 @@ function isHidden(elem) {
 }
 ```
 
-Please note that such `isHidden` returns `true` for elements that are on-screen, but have zero sizes (like an empty `<div>`).
+Please note that such `isHidden` returns `true` for elements that are on-screen, but have zero sizes.
 ````
 
 ## clientTop/Left

2-ui/2-events/01-introduction-browser-events/article.md

@@ -160,7 +160,7 @@ button.onclick = sayThanks;
 button.onclick = sayThanks();
 ```
 
-If we add parentheses, then `sayThanks()` becomes is a function call. So the last line actually takes the *result* of the function execution, that is `undefined` (as the function returns nothing), and assigns it to `onclick`. That doesn't work.
+If we add parentheses, then `sayThanks()` becomes a function call. So the last line actually takes the *result* of the function execution, that is `undefined` (as the function returns nothing), and assigns it to `onclick`. That doesn't work.
 
 ...On the other hand, in the markup we do need the parentheses: