feat: 🎸 support nepali language for all content

Author: sumn2u

en/numbers/operators.md

@@ -62,7 +62,7 @@ parseInt("40 years"); //40
 parseInt("He was 40"); //NaN
 ```
 
-In JavaScript, if we calculate a number outside the largest possible number it returns `Infinity` .
+In JavaScript, if we calculate a number outside the largest possible number it returns `Infinity`.
 
 ```javascript
 let x =  2 / 0; // Infinity

en/objects/mutable.md

@@ -15,7 +15,7 @@ myObject.key = "another value";
 
 You can add, modify, or delete properties of an object using the dot notation or the square bracket notation.
 
-```python
+```javascript
 let object = {};
 object.foo = 'bar'; // Add property 'foo'
 object['baz'] = 'qux'; // Add property 'baz'

ne/README.md

@@ -1,6 +1,4 @@
-# Table of contents
-
-# सामग्रीको तालिका
+सामग्री तालिका
 
 * [परिचय](README.md)
 * [आधारभूत कुरा](basics/README.md)

ne/SUMMARY.md

@@ -1,33 +1,23 @@
-# Arrays (एरे)
-
-Arrays are a fundamental part of programming. An array is a list of data. We can store a lot of data in one variable, which makes our code more readable and easier to understand. It also makes it much easier to perform functions on related data.
+# एरे
 
 एरेहरू प्रोग्रामिंगको एक मौलिक भाग हो। एरे डेटाको सूची हो। हामी एक चरमा धेरै डेटा भण्डारण गर्न सक्दछौं, जसले हाम्रो कोडलाई अधिक पठनीय र बुझ्न सजिलो बनाउँदछ। यसले सम्बन्धित डेटामा प्रकार्यहरू प्रदर्शन गर्न धेरै सजिलो बनाउँदछ।
 
-The data in arrays are called **elements**.
-
 एरेमा डेटालाई **तत्व** भनिन्छ।
 
-Here is a simple array:
-
 यहाँ एक साधारण एर्रेको उदाहरण छ।
 
 ```javascript
 // 1, 1, 2, 3, 5, and 8 are the elements in this array
 let numbers = [1, 1, 2, 3, 5, 8];
 ```
 
-Arrays can be created easily using array literals or with a `new` keyword. 
-
 एरेहरू एरे शाब्दिक प्रयोग गरेर वा `नयाँ` कुञ्जीशब्दको साथ सजिलै सिर्जना गर्न सकिन्छ।
 
 ```javascript
 const cars = ["Saab", "Volvo", "BMW"]; // using array literals
 const cars = new Array("Saab", "Volvo", "BMW"); // using the new keyword
 ```
 
-An index number is used to access the values of an array.  The index of the first element in an array is always `0` as array indexes start with `0`. The index number can also be used to change the elements of an array.
-
 अनुक्रमणिका नम्बर एरेको मानमा पहुँच गर्न प्रयोग गरिन्छ ।  एरेमा पहिलो तत्वको अनुक्रमणिका जहिले पनि '०' हुन्छ किनकि एरे अनुक्रमणिकाहरू '०' बाट सुरु हुन्छ। अनुक्रमणिका नम्बर पनि एरेको तत्वहरू परिवर्तन गर्न प्रयोग गर्न सकिन्छ।
 
 ```javascript
@@ -42,44 +32,9 @@ console.log(cars);
 
 {% hint style="warning" %}
 
-
-Arrays are a special type of object.  One can have [objects](../objects/) in an array.
-
 एरेहरू एक विशेष प्रकारको वस्तु हो। एरेमा [वस्तुहरू](../objects/) हुन सक्छन्।
 {% endhint %}
 
- The `length` property of an array returns the count of numbers elements.  Methods supported by Arrays are shown below:
-
-| Name              | Description                                                                                                                                       |
-| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `concat()`        | Returns two or more combined arrays                                                                                                               |
-| `join()`          | Joins all elements in an array into a string                                                                                                      |
-| `push()`          | Adds one or more elements at the end of the array and returns the length                                                                          |
-| `pop()`           | Removes the last element of an array and returns that element                                                                                     |
-| `shift()`         | Removes the first element of an array and returns that element                                                                                    |
-| `unshift()`       | Adds one or more elements at the front of an array and returns the length                                                                         |
-| `slice()`         | Extracts the section of an array and returns the new array                                                                                        |
-| `at()`            | Returns element at the specified index or `undefined`                                                                                             |
-| `splice()`        | Removes elements from an array and (optionally) replaces them, and returns the array                                                              |
-| `reverse()`       | Transposes the elements of an array and returns a reference to an array                                                                           |
-| `flat()`          | Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth                                        |
-| `sort()`          | Sorts the elements of an array in place, and returns a reference to the array                                                                     |
-| `indexOf()`       | Returns the index of the first match of the search element                                                                                        |
-| `lastIndexOf()`   | Returns the index of the last match of the search element                                                                                         |
-| `forEach()`       | Executes a callback in each element of an array and returns undefined                                                                             |
-| `map()`           | Returns a new array with a return value from executing `callback` on every array item.                                                            |
-| `flatMap()`       | Runs `map()` followed by `flat()` of depth 1                                                                                                      |
-| `filter()`        | Returns a new array containing the items for which `callback` returned `true`                                                                     |
-| `find()`          | Returns the first item for which `callback` returned `true`                                                                                       |
-| `findLast()`      | Returns the last item for which `callback` returned `true`                                                                                        |
-| `findIndex()`     | Returns the index of the first item for which `callback` returned `true`                                                                          |
-| `findLastIndex()` | Returns the index of the last item for which `callback` returned `true`                                                                           |
-| `every()`         | Returns `true` if `callback` returns `true` for every item in the array                                                                           |
-| `some()`          | Returns `true` if `callback` returns `true` for at least one item in the array                                                                    |
-| `reduce()`        | Uses `callback(accumulator, currentValue, currentIndex, array)` for reducing purpose and returns the final value returned by `callback` function  |
-| `reduceRight()`   | Works similarly lie `reduce()` but starts with the last element                                                                                   |
-
-
 एरेको 'लम्बाइ' गुणले संख्या तत्वहरूको गणना फर्काउँछ।  एरेद्वारा समर्थित विधिहरू तल देखाइएको छ:
 
 

ne/arrays/README.md

@@ -1,6 +1,4 @@
-# For Each (प्रत्येकको लागि)
-
-The `forEach` method executes a provided function once for each array element. Here's the syntax for using `forEach`:
+# प्रत्येकको लागि
 
 `फोरएच` विधिले प्रत्येक सरणी तत्वका लागि एक पटक प्रदान गरिएको प्रकार्य कार्यान्वयन गर्दछ । यहाँ 'फोरएच' प्रयोग गर्नका लागि वाक्यरचना छ।
 
@@ -12,9 +10,6 @@ array.forEach(function(element, index, array) {
 });
 ```
 
-
-For example, let's say you have an array of numbers and you want to print the double of each number to the console. You could do this using `forEach` like this:
-
 उदाहरणका लागि, मानौँ कि तपाईंसँग संख्याहरूको सरणी छ र तपाईं कन्सोलमा प्रत्येक नम्बरको डबल मुद्रण गर्न चाहनुहुन्छ। तपाईं 'फोरएच' प्रयोग गरेर यो गर्न सक्नुहुनेछ:
 
 ```typescript
@@ -24,8 +19,6 @@ numbers.forEach(function(number) {
 });
 ```
 
-You can also use the arrow function syntax to define the function passed to `forEach`:
-
 तपाईँले `फोरएच` मा पास गरिएको प्रकार्य परिभाषित गर्न बाण प्रकार्य वाक्यरचना पनि प्रयोग गर्न सक्नुहुन्छ ।
 
 ```typescript
@@ -42,14 +35,9 @@ or
 numbers.forEach(number => console.log(number * 2));
 ```
 
- `forEach` does not modify the original array. It simply iterates over the elements of the array and executes the provided function for each element.
-
 `फोरएच` ले मूल एर्रे परिमार्जन गर्दैन । यो केवल एर्रेको तत्वहरूमा पुनरावृत्ति गर्दछ र प्रत्येक तत्वको लागि प्रदान गरिएको प्रकार्य कार्यान्वयन गर्दछ।
 
 {% hint style="warning" %}
 
-
-The `forEach()` method is not executed for the empty statment.
-
 खाली कथनका लागि `forEach()` विधि कार्यान्वयन गरिएको छैन ।
 {% endhint %}

ne/arrays/for-each.md

@@ -1,6 +1,4 @@
-# Indices (सूचकांक)
-
-So you have your array of data elements, but what if you want to access a specific element? That is where indices come in. An **index** refers to a spot in the array. indices logically progress one by one, but it should be noted that the first index in an array is 0, as it is in most languages. Brackets `[]` are used to signify you are referring to an index of an array.
+# सूचकांक
 
 तपाइँसँग डेटा तत्वहरूको तपाईंको एरे छ, तर यदि तपाईं एक विशिष्ट तत्व पहुँच गर्न चाहनुहुन्छ भने के हुन्छ? यहीँबाट इन्डेक्स आउँछ । एक **अनुक्रमणिका** ले सरणीमा एक स्थानलाई बुझाउँछ। सूचकांकहरू तार्किक रूपमा एक-एक गरेर प्रगति गर्छन्, तर यो ध्यान दिनुपर्दछ कि एरेमा पहिलो अनुक्रमणिका ० हो, किनकि यो अधिकांश भाषाहरूमा छ। तपाईँले सरणीको अनुक्रमणिकालाई सङ्केत गर्दै हुनुहुन्छ भन्ने सङ्केत गर्न कोष्ठक `[]` प्रयोग गरिन्छ ।
 
@@ -14,19 +12,15 @@ let fruits = ["apple", "banana", "pineapple", "strawberry"];
 let banana = fruits[1];
 ```
 
-You can also use an array index to set the value of an element in an array:
-
 तपाईँले सरणीमा तत्वको मान सेट गर्न सरणी अनुक्रमणिका पनि प्रयोग गर्न सक्नुहुन्छ ।
 
-```sql
+```javascript
 let array = ['a', 'b', 'c', 'd', 'e'];
 //  indices:  0    1    2    3    4
 array[4] = 'f';
 console.log(array); // Result: ['a', 'b', 'c', 'd', 'f']
 ```
 
-Note that if you try to access or set an element using an index that is outside the bounds of the array (i.e., an index that is less than 0 or greater than or equal to the length of the array), you will get an `undefined` value.
-
 याद गर्नुहोस् कि यदि तपाईँले सरणीको सीमा भन्दा बाहिरको अनुक्रमणिका प्रयोग गरेर तत्व पहुँच गर्न वा सेट गर्न प्रयास गर्नुभयो भने (जस्तै, ० भन्दा कम वा सरणीको लम्बाइभन्दा बढी वा बराबर अनुक्रमणिका), तपाईँले `अपरिभाषित` मान प्राप्त गर्नुहुनेछ।
 
 ```javascript

ne/arrays/indices.md

@@ -1,19 +1,13 @@
-# Join (सामेल)
-
-The `join` method, makes an array turn into a string and joins it all together. It does not change the original array. Here's the syntax for using `join`:
+# सामेल
 
 `सामेल` विधि, एक सरणी एक स्ट्रिंग मा बारी बनाउँछ र यो सबै एक साथ जोडिन्छ। यसले मूल सरणी परिवर्तन गर्दैन । यहाँ 'सामेल' प्रयोग गर्नका लागि वाक्यरचना छ:
 
 ```c
 array.join([separator]);
 ```
 
-The `separator` argument is optional and specifies the character to be used to separate the elements in the resulting string. If omitted, the array elements are separated with a comma (`,`).
-
 `विभाजक (separator)` तर्क वैकल्पिक छ र परिणामी स्ट्रिङमा तत्वहरू अलग गर्न प्रयोग गरिने क्यारेक्टर निर्दिष्ट गर्दछ। यदि छोडियो भने, सरणी तत्वहरू अल्पविराम `(',')` सँग अलग हुन्छन्।
 
-For example:
-
 उदाहरणको लागी:
 
 ```javascript
@@ -26,14 +20,9 @@ console.log(array.join(" "));
 
 {% hint style="warning" %}
 
-
-Any separator can be specified but the default one is a comma `(,)`.
-
 कुनै पनि विभाजक निर्दिष्ट गर्न सकिन्छ तर पूर्वनिर्धारित अल्पविराम `(,)` हो।
 {% endhint %}
 
-In the above example, a space is used as a separator. You can also use `join` to convert an array-like object (such as an arguments object or a NodeList object) to a string by first converting it to an array using the `Array.prototype.slice()` method:
-
 माथिको उदाहरणमा, एक स्थान विभाजकको रूपमा प्रयोग गरिन्छ। तपाईँले एरे जस्तो वस्तु (जस्तै तर्क वस्तु वा नोडसूची वस्तु) लाई स्ट्रिङमा रूपान्तरण गर्न `सामेल` पनि प्रयोग गर्न सक्नुहुन्छ, यसलाई `Array.prototype.slice()` विधि प्रयोग गरेर सरणीमा रूपान्तरण गरेर:
 
 ```javascript

ne/arrays/join.md

@@ -1,8 +1,6 @@
-# Length (लम्बाइ)
+# लम्बाइ
 
-Arrays have a property called `length`, and it's pretty much exactly as it sounds, it's the length of the array.
-
-एरेसँग `लम्बा` भनिने गुण छ, र यो एरेको लम्बाइ हो।
+एरेसँग `लम्बाइ (length)` भनिने गुण छ, र यो एरेको लम्बाइ हो।
 
 ```javascript
 let array = [1, 2, 3];
@@ -12,8 +10,6 @@ let l = array.length;
 // Result: l = 3
 ```
 
-The length property also sets the number of elements in an array. For example.
-
 लम्बाइ गुणले एरेमा तत्वहरूको संख्या पनि सेट गर्दछ। उदाहरणका लागि:
 
 ```javascript
@@ -24,17 +20,13 @@ console.log(fruits);
 // Result: ['Banana', 'Orange']
 ```
 
-You can also use the `length` property to get the last element of an array by using it as an index. For example:
-
 तपाईँले अनुक्रमणिकाको रूपमा प्रयोग गरेर सरणीको अन्तिम तत्व प्राप्त गर्न `लम्बाइ` गुण पनि प्रयोग गर्न सक्नुहुन्छ। उदाहरणका लागि:
 
 ```c
 console.log(fruits[fruits.length - 1]); // Result: Orange
 ```
 
-You can also use the `length` property to add elements to the end of an array. For example:
-
-सरणीको अन्त्यमा तत्वहरू थप्न तपाईँले `लम्बाइ` गुण पनि प्रयोग गर्न सक्नुहुन्छ । उदाहरणका लागि:
+सरणी ( एरे) को अन्त्यमा तत्वहरू थप्न तपाईँले `लम्बाइ` गुण पनि प्रयोग गर्न सक्नुहुन्छ । उदाहरणका लागि:
 
 ```c
 fruits[fruits.length] = "Pineapple";
@@ -43,14 +35,9 @@ console.log(fruits); // Result: ['Banana', 'Orange', 'Pineapple']
 
 {% hint style="info" %}
 
-
-The `length` property is automatically updated when elements are added or removed from the array.
-
 सरणीबाट तत्वहरू थप्दा वा हटाउँदा `लम्बाइ` गुण स्वचालित रूपमा अद्यावधिक हुन्छ।
 {% endhint %}
 
-It's also worth noting that the `length` property is not a method, so you don't need to use parentheses when accessing it. It's simply a property of the array object that you can access like any other object property.
-
 यो पनि टिप्पण योग्य छ कि `लम्बाइ` गुण एक विधि होइन, त्यसैले तपाईं यसलाई पहुँच गर्दा कोष्ठक प्रयोग गर्न आवश्यक छैन।