Refer to all instance methods with .prototype. (mdn#20292)

files/en-us/web/javascript/data_structures/index.md

@@ -121,8 +121,8 @@ JavaScript strings are immutable. This means that once a string is created, it i
 
 However, it is still possible to create another string based on an operation on the original string. For example:
 
-- A substring of the original by picking individual letters or using {{jsxref("String.substr()")}}.
-- A concatenation of two strings using the concatenation operator (`+`) or {{jsxref("String.concat()")}}.
+- A substring of the original by picking individual letters or using [`substring()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring).
+- A concatenation of two strings using the concatenation operator (`+`) or [`concat()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat).
 
 #### Beware of "stringly-typing" your code!
 

files/en-us/web/javascript/guide/functions/index.md

@@ -209,7 +209,7 @@ const e = factorial(5); // e gets the value 120
 
 There are other ways to call functions. There are often cases where a function needs to be called dynamically, or the number of arguments to a function vary, or in which the context of the function call needs to be set to a specific object determined at runtime.
 
-It turns out that _functions are themselves objects_—and in turn, these objects have methods. (See the {{jsxref("Function")}} object.) One of these, the {{jsxref("Function.apply", "apply()")}} method, can be used to achieve this goal.
+It turns out that _functions are themselves objects_ — and in turn, these objects have methods. (See the {{jsxref("Function")}} object.) The [`call()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call) and [`apply()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) methods can be used to achieve this goal.
 
 ## Function scope
 

files/en-us/web/javascript/guide/grammar_and_types/index.md

@@ -630,7 +630,7 @@ The following are examples of string literals:
 
 You should use string literals unless you specifically need to use a `String` object. See {{jsxref("String")}} for details on `String` objects.
 
-You can call any of the {{jsxref("String")}} object's methods on a string literal value. JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the `String.length` property with a string literal:
+You can call any of the {{jsxref("String")}} object's methods on a string literal value. JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the `length` property with a string literal:
 
 ```js
 // Will print the number of symbols in the string including whitespace.

files/en-us/web/javascript/guide/indexed_collections/index.md

@@ -185,7 +185,7 @@ for (let i = 0, div; div = divs[i]; i++) {
 
 This avoids the overhead of checking the length of the array, and ensures that the `div` variable is reassigned to the current item each time around the loop for added convenience.
 
-The {{jsxref("Array.forEach", "forEach()")}} method provides another way of iterating over an array:
+The [`forEach()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) method provides another way of iterating over an array:
 
 ```js
 const colors = ['red', 'green', 'blue'];
@@ -230,61 +230,68 @@ Since JavaScript elements are saved as standard object properties, it is not adv
 
 The {{jsxref("Array")}} object has the following methods:
 
-{{jsxref("Array.concat", "concat()")}} joins two or more arrays and returns a new array.
+The [`concat()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) method joins two or more arrays and returns a new array.
 
 ```js
 let myArray = ['1', '2', '3'];
 myArray = myArray.concat('a', 'b', 'c');
 // myArray is now ["1", "2", "3", "a", "b", "c"]
 ```
 
-{{jsxref("Array.join", "join(delimiter = ',')")}} joins all elements of an array into a string.
+The [`join()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) method joins all elements of an array into a string.
 
 ```js
 const myArray = ['Wind', 'Rain', 'Fire'];
 const list = myArray.join(' - '); // list is "Wind - Rain - Fire"
 ```
 
-{{jsxref("Array.push", "push()")}} adds one or more elements to the end of an array and returns the resulting `length` of the array.
+The [`push()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) method adds one or more elements to the end of an array and returns the resulting `length` of the array.
 
 ```js
 const myArray = ['1', '2'];
 myArray.push('3'); // myArray is now ["1", "2", "3"]
 ```
 
-{{jsxref("Array.pop", "pop()")}} removes the last element from an array and returns that element.
+The [`pop()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) method removes the last element from an array and returns that element.
 
 ```js
 const myArray = ['1', '2', '3'];
 const last = myArray.pop();
 // myArray is now ["1", "2"], last = "3"
 ```
 
-{{jsxref("Array.shift", "shift()")}} removes the first element from an array and returns that element.
+The [`shift()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) method removes the first element from an array and returns that element.
 
 ```js
 const myArray = ['1', '2', '3'];
 const first = myArray.shift();
 // myArray is now ["2", "3"], first is "1"
 ```
 
-{{jsxref("Array.unshift", "unshift()")}} adds one or more elements to the front of an array and returns the new length of the array.
+The [`unshift()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) method adds one or more elements to the front of an array and returns the new length of the array.
 
 ```js
 const myArray = ['1', '2', '3'];
 myArray.unshift('4', '5');
 // myArray becomes ["4", "5", "1", "2", "3"]
 ```
 
-{{jsxref("Array.slice", "slice(start_index, up_to_index)")}} extracts a section of an array and returns a new array.
+The [`slice()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) method extracts a section of an array and returns a new array.
 
 ```js
 let myArray = ['a', 'b', 'c', 'd', 'e'];
 myArray = myArray.slice(1, 4); // starts at index 1 and extracts all elements
                                // until index 3, returning [ "b", "c", "d"]
 ```
 
-{{jsxref("Array.splice", "splice(index, count_to_remove, addElement1, addElement2, ...)")}} removes elements from an array and (optionally) replaces them. It returns the items which were removed from the array.
+The [`at()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at) method returns the element at the specified index in the array, or `undefined` if the index is out of range. It's notably used for negative indices that access elements from the end of the array.
+
+```js
+const myArray = ['a', 'b', 'c', 'd', 'e'];
+myArray.at(-2); // "d", the second-last element of myArray
+```
+
+The [`splice()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) method removes elements from an array and (optionally) replaces them. It returns the items which were removed from the array.
 
 ```js
 const myArray = ['1', '2', '3', '4', '5'];
@@ -295,15 +302,23 @@ myArray.splice(1, 3, 'a', 'b', 'c', 'd');
 // elements in its place.
 ```
 
-{{jsxref("Array.reverse", "reverse()")}} transposes the elements of an array, in place: the first array element becomes the last and the last becomes the first. It returns a reference to the array.
+The [`reverse()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) method transposes the elements of an array, in place: the first array element becomes the last and the last becomes the first. It returns a reference to the array.
 
 ```js
 const myArray = ['1', '2', '3'];
 myArray.reverse();
 // transposes the array so that myArray = ["3", "2", "1"]
 ```
 
-{{jsxref("Array.sort", "sort()")}} sorts the elements of an array in place, and returns a reference to the array.
+The [`flat()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat) method returns a new array with all sub-array elements concatenated into it recursively up to the specified depth.
+
+```js
+let myArray = [1, 2, [3, 4]];
+myArray = myArray.flat();
+// myArray is now [1, 2, 3, 4], since the [3, 4] subarray is flattened
+```
+
+The [`sort()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method sorts the elements of an array in place, and returns a reference to the array.
 
 ```js
 const myArray = ['Wind', 'Rain', 'Fire'];
@@ -335,7 +350,7 @@ myArray.sort(sortFn);
 - if `a` is greater than `b` by the sorting system, return `1` (or any positive number)
 - if `a` and `b` are considered equivalent, return `0`.
 
-{{jsxref("Array.indexOf", "indexOf(searchElement[, fromIndex])")}} searches the array for `searchElement` and returns the index of the first match.
+The [`indexOf()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) method searches the array for `searchElement` and returns the index of the first match.
 
 ```js
 const a = ['a', 'b', 'a', 'b', 'a'];
@@ -346,7 +361,7 @@ console.log(a.indexOf('b', 2)); // logs 3
 console.log(a.indexOf('z')); // logs -1, because 'z' was not found
 ```
 
-{{jsxref("Array.lastIndexOf", "lastIndexOf(searchElement[, fromIndex])")}} works like `indexOf`, but starts at the end and searches backwards.
+The [`lastIndexOf()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) method works like `indexOf`, but starts at the end and searches backwards.
 
 ```js
 const a = ['a', 'b', 'c', 'd', 'a', 'b'];
@@ -357,7 +372,7 @@ console.log(a.lastIndexOf('b', 4)); // 1
 console.log(a.lastIndexOf('z')); // -1
 ```
 
-{{jsxref("Array.forEach", "forEach(callback[, thisObject])")}} executes `callback` on every array item and returns `undefined`.
+The [`forEach()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) method executes `callback` on every array item and returns `undefined`.
 
 ```js
 const a = ['a', 'b', 'c'];
@@ -367,49 +382,89 @@ a.forEach((element) => {
 // logs each item in turn
 ```
 
-{{jsxref("Array.map", "map(callback[, thisObject])")}} returns a new array of the return value from executing `callback` on every array item.
+The [`map()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) method returns a new array of the return value from executing `callback` on every array item.
 
 ```js
 const a1 = ['a', 'b', 'c'];
 const a2 = a1.map((item) => item.toUpperCase());
-console.log(a2); // logs ['A', 'B', 'C']
+console.log(a2); // ['A', 'B', 'C']
 ```
 
-{{jsxref("Array.filter", "filter(callback[, thisObject])")}} returns a new array containing the items for which `callback` returned `true`.
+The [`flatMap()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap) method runs `map()` followed by a `flat()` of depth 1.
+
+```js
+const a1 = ['a', 'b', 'c'];
+const a2 = a1.flatMap((item) => [item.toUpperCase(), item.toLowerCase()]);
+console.log(a2); // ['A', 'a', 'B', 'b', 'C', 'c']
+```
+
+The [`filter()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) method returns a new array containing the items for which `callback` returned `true`.
 
 ```js
 const a1 = ['a', 10, 'b', 20, 'c', 30];
 const a2 = a1.filter((item) => typeof item === 'number');
-console.log(a2); // logs [10, 20, 30]
+console.log(a2); // [10, 20, 30]
+```
+
+The [`find()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) method returns the first item for which `callback` returned `true`.
+
+```js
+const a1 = ['a', 10, 'b', 20, 'c', 30];
+const i = a1.find((item) => typeof item === 'number');
+console.log(i); // 10
+```
+
+The [`findLast()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findLast) method returns the last item for which `callback` returned `true`.
+
+```js
+const a1 = ['a', 10, 'b', 20, 'c', 30];
+const i = a1.findLast((item) => typeof item === 'number');
+console.log(i); // 30
+```
+
+The [`findIndex()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) method returns the index of the first item for which `callback` returned `true`.
+
+```js
+const a1 = ['a', 10, 'b', 20, 'c', 30];
+const i = a1.findIndex((item) => typeof item === 'number');
+console.log(i); // 1
+```
+
+The [`findLastIndex()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findLastIndex) method returns the index of the last item for which `callback` returned `true`.
+
+```js
+const a1 = ['a', 10, 'b', 20, 'c', 30];
+const i = a1.findLastIndex((item) => typeof item === 'number');
+console.log(i); // 5
 ```
 
-{{jsxref("Array.every", "every(callback[, thisObject])")}} returns `true` if `callback` returns `true` for every item in the array.
+The [`every()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) method returns `true` if `callback` returns `true` for every item in the array.
 
 ```js
 function isNumber(value) {
   return typeof value === 'number';
 }
 const a1 = [1, 2, 3];
-console.log(a1.every(isNumber)); // logs true
+console.log(a1.every(isNumber)); // true
 const a2 = [1, '2', 3];
-console.log(a2.every(isNumber)); // logs false
+console.log(a2.every(isNumber)); // false
 ```
 
-{{jsxref("Array.some", "some(callback[, thisObject])")}} returns `true` if `callback` returns `true` for at least one item in the array.
+The [`some()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method returns `true` if `callback` returns `true` for at least one item in the array.
 
 ```js
 function isNumber(value) {
   return typeof value === 'number';
 }
 const a1 = [1, 2, 3];
-console.log(a1.some(isNumber)); // logs true
+console.log(a1.some(isNumber)); // true
 const a2 = [1, '2', 3];
-console.log(a2.some(isNumber)); // logs true
+console.log(a2.some(isNumber)); // true
 const a3 = ['1', '2', '3'];
-console.log(a3.some(isNumber)); // logs false
+console.log(a3.some(isNumber)); // false
 ```
 
-{{jsxref("Array.reduce", "reduce(callback[, initialValue])")}} applies `callback(accumulator, currentValue[, currentIndex[, array]])` for each value in the array for the purpose of reducing the list of items down to a single value. The `reduce` function returns the final value returned by `callback` function.
+The [`reduce()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) method applies `callback(accumulator, currentValue, currentIndex, array)` for each value in the array for the purpose of reducing the list of items down to a single value. The `reduce` function returns the final value returned by `callback` function.
 
 If `initialValue` is specified, then `callback` is called with `initialValue` as the first parameter value and the value of the first item in the array as the second parameter value.
 
@@ -420,10 +475,10 @@ If `callback` needs access to the index of the item being processed, or access t
 ```js
 const a = [10, 20, 30];
 const total = a.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
-console.log(total); // Prints 60
+console.log(total); // 60
 ```
 
-{{jsxref("Array.reduceRight", "reduceRight(callback[, initialValue])")}} works like `reduce()`, but starts with the last element.
+The [`reduceRight()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) method works like `reduce()`, but starts with the last element.
 
 `reduce` and `reduceRight` are the least obvious of the iterative array methods. They should be used for algorithms that combine two values recursively in order to reduce a sequence down to a single value.
 
@@ -517,11 +572,11 @@ arr.property = "value";
 console.log(arr.property);  // Logs "value"
 ```
 
-For example, when an array is the result of a match between a regular expression and a string, the array returns properties and elements that provide information about the match. An array is the return value of {{jsxref("Global_Objects/RegExp/exec","RegExp.exec()")}}, {{jsxref("Global_Objects/String/match","String.match()")}}, and {{jsxref("Global_Objects/String/split","String.split()")}}. For information on using arrays with regular expressions, see [Regular Expressions](/en-US/docs/Web/JavaScript/Guide/Regular_Expressions).
+For example, when an array is the result of a match between a regular expression and a string, the array returns properties and elements that provide information about the match. An array is the return value of [`RegExp.prototype.exec()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec), [`String.prototype.match()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match), and [`String.prototype.split()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split). For information on using arrays with regular expressions, see [Regular Expressions](/en-US/docs/Web/JavaScript/Guide/Regular_Expressions).
 
 ## Working with array-like objects
 
-Some JavaScript objects, such as the [`NodeList`](/en-US/docs/Web/API/NodeList) returned by [`document.getElementsByTagName()`](/en-US/docs/Web/API/Document/getElementsByTagName) or the {{jsxref("Functions/arguments","arguments")}} object made available within the body of a function, look and behave like arrays on the surface but do not share all of their methods. The `arguments` object provides a {{jsxref("Global_Objects/Function/length","length")}} attribute but does not implement the {{jsxref("Array.forEach", "forEach()")}} method, for example.
+Some JavaScript objects, such as the [`NodeList`](/en-US/docs/Web/API/NodeList) returned by [`document.getElementsByTagName()`](/en-US/docs/Web/API/Document/getElementsByTagName) or the {{jsxref("Functions/arguments","arguments")}} object made available within the body of a function, look and behave like arrays on the surface but do not share all of their methods. The `arguments` object provides a {{jsxref("Global_Objects/Function/length","length")}} attribute but does not implement array methods like [`forEach()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach).
 
 Array methods cannot be called directly on array-like objects.
 

files/en-us/web/javascript/guide/modules/index.md

@@ -493,7 +493,7 @@ Let's look at an example. In the [dynamic-module-imports](https://github.com/mdn
 
 In this example we've only made changes to our [`index.html`](https://github.com/mdn/js-examples/blob/master/module-examples/dynamic-module-imports/index.html) and [`main.js`](https://github.com/mdn/js-examples/blob/master/module-examples/dynamic-module-imports/main.js) files — the module exports remain the same as before.
 
-Over in `main.js` we've grabbed a reference to each button using a [`Document.querySelector()`](/en-US/docs/Web/API/Document/querySelector) call, for example:
+Over in `main.js` we've grabbed a reference to each button using a [`document.querySelector()`](/en-US/docs/Web/API/Document/querySelector) call, for example:
 
 ```js
 const squareBtn = document.querySelector('.square');