From 0061defd8d46a295010de1c690ee7c084b8fe3f9 Mon Sep 17 00:00:00 2001 From: Nikolay Gagarinov Date: Tue, 29 Apr 2025 19:08:09 +0500 Subject: [PATCH] remove replit --- modules/10-basics/20-comments/description.es.yml | 1 - modules/10-basics/20-comments/en/README.md | 2 -- modules/10-basics/20-comments/es/README.md | 2 -- modules/10-basics/20-comments/ru/README.md | 2 -- modules/10-basics/40-instructions/description.es.yml | 1 - modules/10-basics/40-instructions/es/README.md | 2 -- modules/10-basics/40-instructions/ru/README.md | 2 -- modules/10-basics/45-testing/description.es.yml | 2 +- modules/10-basics/45-testing/en/README.md | 2 +- modules/10-basics/45-testing/es/README.md | 2 +- modules/10-basics/45-testing/ru/README.md | 2 +- modules/10-basics/50-syntax-errors/description.es.yml | 4 ---- modules/10-basics/50-syntax-errors/en/README.md | 2 +- modules/10-basics/50-syntax-errors/es/README.md | 4 ---- modules/10-basics/50-syntax-errors/ru/README.md | 4 ---- modules/20-arithmetics/20-basic/description.es.yml | 1 - modules/20-arithmetics/20-basic/es/README.md | 2 -- modules/20-arithmetics/20-basic/ru/README.md | 2 -- modules/20-arithmetics/25-operator/ru/README.md | 2 -- modules/20-arithmetics/30-composition/description.es.yml | 1 - modules/20-arithmetics/30-composition/en/README.md | 2 -- modules/20-arithmetics/30-composition/es/README.md | 2 -- modules/20-arithmetics/30-composition/ru/README.md | 2 -- modules/20-arithmetics/40-priority/description.es.yml | 1 - modules/20-arithmetics/40-priority/es/README.md | 2 -- modules/20-arithmetics/40-priority/ru/README.md | 2 -- modules/20-arithmetics/60-infinity/description.es.yml | 1 - modules/20-arithmetics/60-infinity/es/README.md | 2 -- modules/20-arithmetics/60-infinity/ru/README.md | 2 -- modules/20-arithmetics/70-nan/description.es.yml | 1 - modules/20-arithmetics/70-nan/es/README.md | 2 -- modules/20-arithmetics/70-nan/ru/README.md | 2 -- modules/25-strings/15-escape-characters/description.es.yml | 5 +---- modules/25-strings/15-escape-characters/en/data.yml | 3 --- modules/25-strings/15-escape-characters/es/data.yml | 6 +----- modules/25-strings/15-escape-characters/ru/data.yml | 3 --- .../25-strings/20-string-concatenation/description.es.yml | 1 - modules/25-strings/20-string-concatenation/en/README.md | 2 -- modules/25-strings/20-string-concatenation/es/README.md | 2 -- modules/25-strings/20-string-concatenation/ru/README.md | 2 -- modules/25-strings/30-encoding/description.es.yml | 1 - modules/25-strings/30-encoding/es/EXERCISE.md | 2 -- modules/25-strings/30-encoding/ru/EXERCISE.md | 2 -- modules/30-variables/10-definition/description.es.yml | 1 - modules/30-variables/10-definition/es/README.md | 2 -- modules/30-variables/10-definition/ru/README.md | 2 -- modules/30-variables/11-change/description.es.yml | 1 - modules/30-variables/11-change/es/README.md | 2 -- modules/30-variables/11-change/ru/README.md | 2 -- .../15-variables-expressions/description.es.yml | 2 -- modules/30-variables/15-variables-expressions/en/README.md | 2 -- modules/30-variables/15-variables-expressions/es/README.md | 2 -- modules/30-variables/15-variables-expressions/ru/README.md | 2 -- .../18-variable-concatenation/description.es.yml | 1 - modules/30-variables/18-variable-concatenation/en/README.md | 2 -- modules/30-variables/18-variable-concatenation/es/README.md | 2 -- modules/30-variables/18-variable-concatenation/ru/README.md | 2 -- modules/30-variables/23-constants/description.es.yml | 1 - modules/30-variables/23-constants/en/README.md | 2 -- modules/30-variables/23-constants/es/README.md | 2 -- modules/30-variables/23-constants/ru/README.md | 2 -- modules/30-variables/25-interpolation/description.es.yml | 1 - modules/30-variables/25-interpolation/en/README.md | 2 -- modules/30-variables/25-interpolation/es/README.md | 2 -- modules/30-variables/25-interpolation/ru/README.md | 2 -- modules/30-variables/30-symbols/description.es.yml | 1 - modules/30-variables/30-symbols/es/README.md | 2 -- modules/30-variables/30-symbols/ru/README.md | 2 -- .../10-primitive-data-types/description.es.yml | 1 - modules/33-data-types/10-primitive-data-types/es/README.md | 2 -- modules/33-data-types/10-primitive-data-types/ru/README.md | 2 -- modules/33-data-types/45-undefined/description.es.yml | 2 -- modules/33-data-types/45-undefined/es/README.md | 2 -- modules/33-data-types/45-undefined/ru/README.md | 2 -- .../50-data-types-weak-typing/description.es.yml | 1 - .../33-data-types/50-data-types-weak-typing/en/README.md | 2 -- .../33-data-types/50-data-types-weak-typing/es/README.md | 2 -- .../33-data-types/50-data-types-weak-typing/ru/README.md | 2 -- modules/35-calling-functions/110-math/ru/README.md | 2 -- .../120-function-signature/description.es.yml | 1 - .../120-function-signature/es/README.md | 2 -- .../120-function-signature/ru/README.md | 2 -- .../35-calling-functions/270-deterministic/en/EXERCISE.md | 2 -- .../38-properties/100-properties-syntax/description.es.yml | 1 - modules/38-properties/100-properties-syntax/es/README.md | 2 -- modules/38-properties/100-properties-syntax/ru/README.md | 2 -- .../38-properties/200-properties-methods/description.es.yml | 1 - modules/38-properties/200-properties-methods/es/README.md | 2 -- modules/38-properties/200-properties-methods/ru/README.md | 2 -- .../300-properties-immutability/description.es.yml | 1 - .../38-properties/300-properties-immutability/es/README.md | 2 -- .../38-properties/300-properties-immutability/ru/README.md | 2 -- .../400-properties-expressions/description.es.yml | 1 - .../38-properties/400-properties-expressions/en/README.md | 2 -- .../38-properties/400-properties-expressions/es/README.md | 2 -- .../38-properties/400-properties-expressions/ru/README.md | 2 -- .../100-define-functions-syntax/description.es.yml | 1 - .../100-define-functions-syntax/en/README.md | 2 -- .../100-define-functions-syntax/es/README.md | 2 -- .../100-define-functions-syntax/ru/README.md | 2 -- .../150-define-functions-return/description.es.yml | 1 - .../150-define-functions-return/en/README.md | 2 -- .../150-define-functions-return/es/README.md | 2 -- .../150-define-functions-return/ru/README.md | 2 -- .../320-define-functions-parameters/description.es.yml | 1 - .../320-define-functions-parameters/es/README.md | 2 -- .../320-define-functions-parameters/ru/README.md | 2 -- .../description.es.yml | 1 - .../340-define-functions-default-parameters/es/README.md | 2 -- .../340-define-functions-default-parameters/ru/README.md | 2 -- .../450-define-functions-short-syntax/description.es.yml | 1 - .../450-define-functions-short-syntax/es/README.md | 2 -- .../450-define-functions-short-syntax/ru/README.md | 2 -- modules/45-logic/10-bool-type/description.es.yml | 1 - modules/45-logic/10-bool-type/es/README.md | 2 -- modules/45-logic/10-bool-type/ru/README.md | 2 -- modules/45-logic/15-predicates/description.es.yml | 1 - modules/45-logic/15-predicates/es/README.md | 2 -- modules/45-logic/15-predicates/ru/README.md | 2 -- .../20-logic-combine-expressions/description.es.yml | 1 - modules/45-logic/20-logic-combine-expressions/en/README.md | 2 -- modules/45-logic/20-logic-combine-expressions/es/README.md | 2 -- modules/45-logic/20-logic-combine-expressions/ru/README.md | 2 -- modules/45-logic/25-logical-operators/description.es.yml | 1 - modules/45-logic/25-logical-operators/es/README.md | 2 -- modules/45-logic/25-logical-operators/ru/README.md | 2 -- modules/45-logic/28-logical-negation/description.es.yml | 1 - modules/45-logic/28-logical-negation/es/README.md | 2 -- modules/45-logic/28-logical-negation/ru/README.md | 2 -- modules/45-logic/70-logical-expressions/description.es.yml | 1 - modules/45-logic/70-logical-expressions/es/README.md | 2 -- modules/45-logic/70-logical-expressions/ru/README.md | 2 -- modules/48-conditionals/30-if/description.es.yml | 1 - modules/48-conditionals/30-if/es/README.md | 2 -- modules/48-conditionals/30-if/ru/README.md | 2 -- modules/48-conditionals/40-if-else/description.es.yml | 1 - modules/48-conditionals/40-if-else/es/README.md | 2 -- modules/48-conditionals/40-if-else/ru/README.md | 2 -- modules/48-conditionals/50-else-if/description.es.yml | 1 - modules/48-conditionals/50-else-if/en/README.md | 2 -- modules/48-conditionals/50-else-if/es/README.md | 2 -- modules/48-conditionals/50-else-if/ru/README.md | 2 -- .../48-conditionals/60-ternary-operator/description.es.yml | 1 - modules/48-conditionals/60-ternary-operator/es/README.md | 2 -- modules/48-conditionals/60-ternary-operator/ru/README.md | 2 -- modules/48-conditionals/65-switch/description.es.yml | 1 - modules/48-conditionals/65-switch/es/README.md | 2 -- modules/48-conditionals/65-switch/ru/README.md | 2 -- modules/50-loops/10-while/description.es.yml | 1 - modules/50-loops/10-while/en/README.md | 2 -- modules/50-loops/10-while/es/README.md | 2 -- modules/50-loops/10-while/ru/README.md | 2 -- modules/50-loops/20-aggregation-numbers/description.es.yml | 1 - modules/50-loops/20-aggregation-numbers/es/README.md | 2 -- modules/50-loops/20-aggregation-numbers/ru/README.md | 2 -- modules/50-loops/23-aggregation-strings/description.es.yml | 1 - modules/50-loops/23-aggregation-strings/en/README.md | 2 -- modules/50-loops/23-aggregation-strings/es/README.md | 2 -- modules/50-loops/23-aggregation-strings/ru/README.md | 2 -- .../50-loops/25-iteration-over-string/description.es.yml | 1 - modules/50-loops/25-iteration-over-string/es/README.md | 2 -- modules/50-loops/25-iteration-over-string/ru/README.md | 2 -- .../50-loops/26-conditions-inside-loops/description.es.yml | 1 - modules/50-loops/26-conditions-inside-loops/es/README.md | 2 -- modules/50-loops/26-conditions-inside-loops/ru/README.md | 2 -- modules/50-loops/28-build-strings/description.es.yml | 1 - modules/50-loops/28-build-strings/en/README.md | 2 -- modules/50-loops/28-build-strings/es/README.md | 2 -- modules/50-loops/28-build-strings/ru/README.md | 2 -- modules/50-loops/50-mutators/description.es.yml | 1 - modules/50-loops/50-mutators/es/README.md | 2 -- modules/50-loops/50-mutators/ru/README.md | 2 -- modules/50-loops/55-return-from-loops/description.es.yml | 1 - modules/50-loops/55-return-from-loops/en/README.md | 2 -- modules/50-loops/55-return-from-loops/es/README.md | 2 -- modules/50-loops/55-return-from-loops/ru/README.md | 2 -- modules/50-loops/70-for/description.es.yml | 1 - modules/50-loops/70-for/es/README.md | 2 -- modules/50-loops/70-for/ru/README.md | 2 -- 179 files changed, 7 insertions(+), 319 deletions(-) diff --git a/modules/10-basics/20-comments/description.es.yml b/modules/10-basics/20-comments/description.es.yml index 2695cf42..a4946543 100644 --- a/modules/10-basics/20-comments/description.es.yml +++ b/modules/10-basics/20-comments/description.es.yml @@ -41,7 +41,6 @@ theory: | console.log('I am the King'); ``` - https://replit.com/@hexlet/helloworld Estos comentarios generalmente se utilizan para la documentación del código, por ejemplo, en el caso de las funciones. diff --git a/modules/10-basics/20-comments/en/README.md b/modules/10-basics/20-comments/en/README.md index 1b0e0e9f..990b9ae1 100644 --- a/modules/10-basics/20-comments/en/README.md +++ b/modules/10-basics/20-comments/en/README.md @@ -24,6 +24,4 @@ console.log('I am the King'); // For Lannisters! console.log('I am the King'); ``` -https://replit.com/@hexlet/helloworld - Such comments usually clarify the purpose of pieces of code. diff --git a/modules/10-basics/20-comments/es/README.md b/modules/10-basics/20-comments/es/README.md index f7fddfa3..f429a8b7 100644 --- a/modules/10-basics/20-comments/es/README.md +++ b/modules/10-basics/20-comments/es/README.md @@ -37,6 +37,4 @@ Los *comentarios de varias líneas* comienzan con `/*` y terminan con `*/`. console.log('I am the King'); ``` -https://replit.com/@hexlet/helloworld - Estos comentarios generalmente se utilizan para la documentación del código, por ejemplo, en el caso de las funciones. diff --git a/modules/10-basics/20-comments/ru/README.md b/modules/10-basics/20-comments/ru/README.md index fadb17a8..1bef8296 100644 --- a/modules/10-basics/20-comments/ru/README.md +++ b/modules/10-basics/20-comments/ru/README.md @@ -37,6 +37,4 @@ console.log('I am the King'); // For Lannisters! console.log('I am the King'); ``` -https://replit.com/@hexlet/helloworld - Такие комментарии, обычно, используют для документирования кода, например, функций. diff --git a/modules/10-basics/40-instructions/description.es.yml b/modules/10-basics/40-instructions/description.es.yml index e1ddb3dd..fd2f14e0 100644 --- a/modules/10-basics/40-instructions/description.es.yml +++ b/modules/10-basics/40-instructions/description.es.yml @@ -11,7 +11,6 @@ theory: | console.log('Dracarys!'); ``` - https://replit.com/@hexlet/js-basics-instructions Al ejecutar este código, se mostrarán en pantalla las dos frases de forma secuencial: diff --git a/modules/10-basics/40-instructions/es/README.md b/modules/10-basics/40-instructions/es/README.md index 0927abff..2ce6a01b 100644 --- a/modules/10-basics/40-instructions/es/README.md +++ b/modules/10-basics/40-instructions/es/README.md @@ -7,8 +7,6 @@ console.log('Mother of Dragons.'); console.log('Dracarys!'); ``` -https://replit.com/@hexlet/js-basics-instructions - Al ejecutar este código, se mostrarán en pantalla las dos frases de forma secuencial: 
diff --git a/modules/10-basics/40-instructions/ru/README.md b/modules/10-basics/40-instructions/ru/README.md
index 0c39d45a..07d50343 100644
--- a/modules/10-basics/40-instructions/ru/README.md
+++ b/modules/10-basics/40-instructions/ru/README.md
@@ -7,8 +7,6 @@ console.log('Mother of Dragons.');
 console.log('Dracarys!');
 ```
 
-https://replit.com/@hexlet/js-basics-instructions
-
 При запуске этого кода, на экран последовательно выводятся два предложения:
 
 
diff --git a/modules/10-basics/45-testing/description.es.yml b/modules/10-basics/45-testing/description.es.yml
index 9ac7f850..d4a50f7c 100644
--- a/modules/10-basics/45-testing/description.es.yml
+++ b/modules/10-basics/45-testing/description.es.yml
@@ -30,7 +30,7 @@ theory: |
 
   Expected es el valor esperado y Received es el valor que devolvió tu código.
 
-  Además de nuestras pruebas, es muy útil experimentar con el código en la consola del [navegador](https://developer.mozilla.org/es/docs/Tools/Consola_de_navegador). En cualquier situación en la que no entiendas algo o quieras probar diferentes formas de uso, no dudes en abrir la consola e ingresar el código allí. Sería ideal si ejecutas todo el código presente en las lecciones por tu cuenta. Además de la consola, es útil usar el servicio [repl.it](https://repl.it/languages/javascript).
+  Además de nuestras pruebas, es muy útil experimentar con el código en la consola del [navegador](https://developer.mozilla.org/es/docs/Tools/Consola_de_navegador). En cualquier situación en la que no entiendas algo o quieras probar diferentes formas de uso, no dudes en abrir la consola e ingresar el código allí. Sería ideal si ejecutas todo el código presente en las lecciones por tu cuenta.
 
   ---
 
diff --git a/modules/10-basics/45-testing/en/README.md b/modules/10-basics/45-testing/en/README.md
index 98985d51..46f91070 100644
--- a/modules/10-basics/45-testing/en/README.md
+++ b/modules/10-basics/45-testing/en/README.md
@@ -24,7 +24,7 @@ One of your tasks in the following lessons will be to write a function that perf
     "ello, World!"
 

 
-In addition to our tests, it's very useful to experiment with code in the [browser console](https://developer.mozilla.org/en-US/docs/Tools/Browser_Console). When something isn't clear to you, or you want to experiment with code, feel free to do all of this in the console. Ideally, it's best to execute all the code given in the lessons on your own. In addition to the console, you can also use [repl.it](https://repl.it/languages/javascript).
+In addition to our tests, it's very useful to experiment with code in the [browser console](https://developer.mozilla.org/en-US/docs/Tools/Browser_Console). When something isn't clear to you, or you want to experiment with code, feel free to do all of this in the console.
 
 Sometimes when creating a solution, it may seem that you have done everything correctly, but the system has got into a huff and won't accept your solution. Such cases are borderline impossible. Failed tests simply won't get as far as the site, they are automatically run after each change. In the vast majority of cases (all our projects have been run millions of times in total over many years) the error is in the solution code. It can be very imperceptible, maybe you used the wrong punctuation, or you used upper case instead of lower case, or you missed a comma. Other cases are more complicated. Maybe your solution works for one set of inputs, but not for another. So always read the instructions and test your output carefully. There will almost certainly be some sign of an error.
 
diff --git a/modules/10-basics/45-testing/es/README.md b/modules/10-basics/45-testing/es/README.md
index c9636444..ae6dd9d0 100644
--- a/modules/10-basics/45-testing/es/README.md
+++ b/modules/10-basics/45-testing/es/README.md
@@ -26,7 +26,7 @@ Aquí tienes un ejemplo sencillo: en una de las futuras lecciones, tendrás que
 
 Expected es el valor esperado y Received es el valor que devolvió tu código.
 
-Además de nuestras pruebas, es muy útil experimentar con el código en la consola del [navegador](https://developer.mozilla.org/es/docs/Tools/Consola_de_navegador). En cualquier situación en la que no entiendas algo o quieras probar diferentes formas de uso, no dudes en abrir la consola e ingresar el código allí. Sería ideal si ejecutas todo el código presente en las lecciones por tu cuenta. Además de la consola, es útil usar el servicio [repl.it](https://repl.it/languages/javascript).
+Además de nuestras pruebas, es muy útil experimentar con el código en la consola del [navegador](https://developer.mozilla.org/es/docs/Tools/Consola_de_navegador). En cualquier situación en la que no entiendas algo o quieras probar diferentes formas de uso, no dudes en abrir la consola e ingresar el código allí.
 
 ---
 
diff --git a/modules/10-basics/45-testing/ru/README.md b/modules/10-basics/45-testing/ru/README.md
index 6e86eb8c..4d2fe3ac 100644
--- a/modules/10-basics/45-testing/ru/README.md
+++ b/modules/10-basics/45-testing/ru/README.md
@@ -26,7 +26,7 @@
 
 Expected – ожидаемое значение, а Received, то которое выдал ваш код.
 
-Кроме наших тестов, будет крайне полезно экспериментировать с кодом в консоли [браузера](https://developer.mozilla.org/en-US/docs/Tools/Browser_Console). В любой ситуации, когда вы недопоняли, или хотите попробовать разные варианты использования, смело открывайте консоль и вводите туда код. Идеально, если вы выполните самостоятельно весь код, который присутствует в уроках. Кроме консоли, полезно использовать сервис [repl.it](https://repl.it/languages/javascript).
+Кроме наших тестов, будет крайне полезно экспериментировать с кодом в консоли [браузера](https://developer.mozilla.org/en-US/docs/Tools/Browser_Console). В любой ситуации, когда вы недопоняли, или хотите попробовать разные варианты использования, смело открывайте консоль и вводите туда код.
 
 ---
 
diff --git a/modules/10-basics/50-syntax-errors/description.es.yml b/modules/10-basics/50-syntax-errors/description.es.yml
index 0930b44d..3e9e96c5 100644
--- a/modules/10-basics/50-syntax-errors/description.es.yml
+++ b/modules/10-basics/50-syntax-errors/description.es.yml
@@ -13,10 +13,6 @@ theory: |
 
   Si ejecutamos el código anterior, veremos el siguiente mensaje: `SyntaxError: missing ) after argument list`, así como una indicación de la línea y el archivo donde se produjo este error. Estos errores de sintaxis en JavaScript se clasifican como SyntaxError.
 
-  *Por razones técnicas, este código ejecutado en https://code-basics.com no mostrará la línea y el archivo. Puede verificar esta salida en https://repl.it*
-
-  https://replit.com/@hexlet/js-basics-syntax-errors
-
   Por un lado, los errores de SyntaxError son los más simples porque están relacionados exclusivamente con las reglas gramaticales de escritura de código, no con el significado del código en sí. Son fáciles de corregir: solamente necesitas encontrar la violación de las reglas gramaticales.
 
   Por otro lado, el intérprete no siempre puede señalar claramente estas infracciones. Por lo tanto, a veces sucede que hay que colocar el paréntesis olvidado no donde indica precisamente el mensaje de error.
diff --git a/modules/10-basics/50-syntax-errors/en/README.md b/modules/10-basics/50-syntax-errors/en/README.md
index 215ef9ed..89d1d1fb 100644
--- a/modules/10-basics/50-syntax-errors/en/README.md
+++ b/modules/10-basics/50-syntax-errors/en/README.md
@@ -6,7 +6,7 @@ Here is an example of some code with a syntax error:
 console.log('Hodor'
 ```
 
-If we run this code we will see the following message: `SyntaxError: missing ) after the argument list`. In JavaScript, these errors are labelled as "SyntaxError". For technical reasons, this code running on [code-basics] (https://code-basics.com) won't show a message with a line and file. You can check this output on [repl.it] (https://repl.it).
+If we run this code we will see the following message: `SyntaxError: missing ) after the argument list`. In JavaScript, these errors are labelled as "SyntaxError".
 
 On the one hand, syntax errors are the most obvious because they deal with code grammar rules and have nothing to do with its logic. You can easily fix it once you find it.
 
diff --git a/modules/10-basics/50-syntax-errors/es/README.md b/modules/10-basics/50-syntax-errors/es/README.md
index d35ad44b..0b6f6fc0 100644
--- a/modules/10-basics/50-syntax-errors/es/README.md
+++ b/modules/10-basics/50-syntax-errors/es/README.md
@@ -9,10 +9,6 @@ console.log('Hodor'
 
 Si ejecutamos el código anterior, veremos el siguiente mensaje: `SyntaxError: missing ) after argument list`, así como una indicación de la línea y el archivo donde se produjo este error. Estos errores de sintaxis en JavaScript se clasifican como SyntaxError.
 
-*Por razones técnicas, este código ejecutado en https://code-basics.com no mostrará la línea y el archivo. Puede verificar esta salida en https://repl.it*
-
-https://replit.com/@hexlet/js-basics-syntax-errors
-
 Por un lado, los errores de SyntaxError son los más simples porque están relacionados exclusivamente con las reglas gramaticales de escritura de código, no con el significado del código en sí. Son fáciles de corregir: solamente necesitas encontrar la violación de las reglas gramaticales.
 
 Por otro lado, el intérprete no siempre puede señalar claramente estas infracciones. Por lo tanto, a veces sucede que hay que colocar el paréntesis olvidado no donde indica precisamente el mensaje de error.
diff --git a/modules/10-basics/50-syntax-errors/ru/README.md b/modules/10-basics/50-syntax-errors/ru/README.md
index c6e7f168..89cf54d7 100644
--- a/modules/10-basics/50-syntax-errors/ru/README.md
+++ b/modules/10-basics/50-syntax-errors/ru/README.md
@@ -9,10 +9,6 @@ console.log('Hodor'
 
 Если запустить код выше, то мы увидим следующее сообщение: `SyntaxError: missing ) after argument list`, а также указание на строку и файл, где возникла эта ошибка. Подобные синтаксические ошибки в JavaScript относятся к разряду SyntaxError.
 
-*По техническим причинам, такой код, запущенный на https://code-basics.com не укажет на строку и файл. Проверить этот вывод можно на https://repl.it*
-
-https://replit.com/@hexlet/js-basics-syntax-errors
-
 С одной стороны, ошибки SyntaxError — самые простые, потому что они связаны исключительно с грамматическими правилами написания кода, а не с самим смыслом кода. Их легко исправить: нужно лишь найти нарушение в записи.
 
 С другой стороны, интерпретатор не всегда может чётко указать на это нарушение. Поэтому бывает, что забытую скобку нужно поставить не туда, куда указывает сообщение об ошибке.
diff --git a/modules/20-arithmetics/20-basic/description.es.yml b/modules/20-arithmetics/20-basic/description.es.yml
index 36a6c3be..27256bc9 100644
--- a/modules/20-arithmetics/20-basic/description.es.yml
+++ b/modules/20-arithmetics/20-basic/description.es.yml
@@ -41,7 +41,6 @@ theory: |
   console.log(3 ** 2); // => 9
   ```
 
-  https://replit.com/@hexlet/js-basics-arithmetics-basics
 
   A veces, para mayor comodidad, mostraremos el resultado de la ejecución de las líneas de código en los comentarios, de esta manera: `=> RESULTADO`. Por ejemplo, `// => 4`.
 
diff --git a/modules/20-arithmetics/20-basic/es/README.md b/modules/20-arithmetics/20-basic/es/README.md
index 46aa15f8..03c07435 100644
--- a/modules/20-arithmetics/20-basic/es/README.md
+++ b/modules/20-arithmetics/20-basic/es/README.md
@@ -37,8 +37,6 @@ console.log(8 / 2);  // => 4
 console.log(3 ** 2); // => 9
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-basics
-
 A veces, para mayor comodidad, mostraremos el resultado de la ejecución de las líneas de código en los comentarios, de esta manera: `=> RESULTADO`. Por ejemplo, `// => 4`.
 
 La primera instrucción mostrará `4` en la pantalla (porque 8 / 2 es igual a 4), y la segunda instrucción mostrará 9 en la pantalla (porque 32 es igual a 9).
diff --git a/modules/20-arithmetics/20-basic/ru/README.md b/modules/20-arithmetics/20-basic/ru/README.md
index 04b2b3ea..b02e672e 100644
--- a/modules/20-arithmetics/20-basic/ru/README.md
+++ b/modules/20-arithmetics/20-basic/ru/README.md
@@ -37,8 +37,6 @@ console.log(8 / 2); // => 4
 console.log(3 ** 2); // => 9
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-basics
-
 Иногда для удобства мы будем показывать в комментариях результат запуска строчек кода, вот так: `=> РЕЗУЛЬТАТ`. Например, `// => 4`.
 
 Первая инструкция выведет на экран `4` (потому что 8 / 2 это 4), а вторая инструкция выведет на экран 9 (потому что 32 это 9).
diff --git a/modules/20-arithmetics/25-operator/ru/README.md b/modules/20-arithmetics/25-operator/ru/README.md
index 105580f6..d566570c 100644
--- a/modules/20-arithmetics/25-operator/ru/README.md
+++ b/modules/20-arithmetics/25-operator/ru/README.md
@@ -5,8 +5,6 @@
 console.log(8 + 2);
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-operator
-
 В этом примере `+` — это **оператор**, а числа `8` и `2` — это **операнды**.
 
 В случае сложения у нас есть два операнда: один слева, другой справа от знака `+`. Операции, которые требуют наличия двух операндов, называются **бинарными**. Если пропустить хотя бы один операнд, например, `3 + ;`, то программа завершится с синтаксической ошибкой.
diff --git a/modules/20-arithmetics/30-composition/description.es.yml b/modules/20-arithmetics/30-composition/description.es.yml
index 4dd97677..767cbd2c 100644
--- a/modules/20-arithmetics/30-composition/description.es.yml
+++ b/modules/20-arithmetics/30-composition/description.es.yml
@@ -16,7 +16,6 @@ theory: |
   console.log(2 * 4 * 5 * 10);
   ```
 
-  https://replit.com/@hexlet/js-basics-arithmetics-composition
 
   Como puedes ver, las operaciones se pueden combinar entre sí, lo que nos permite calcular expresiones compuestas más complejas. Para entender cómo se realizan los cálculos dentro del intérprete, analicemos el ejemplo: `2 * 4 * 5 * 10`.
 
diff --git a/modules/20-arithmetics/30-composition/en/README.md b/modules/20-arithmetics/30-composition/en/README.md
index 85710095..f914e84f 100644
--- a/modules/20-arithmetics/30-composition/en/README.md
+++ b/modules/20-arithmetics/30-composition/en/README.md
@@ -11,8 +11,6 @@ console.log(2 * 4 * 5 * 10);
 ```
 
  As you can see, we can combine operations, which allows us to compute even more complex compound expressions. To visualize how calculations are done inside the interpreter, let's look at an example: `2 * 4 * 5 * 10`.
-
-
 1. First we calculate `2 * 4` and get `8 * 5 * 10`
 2. Then we calculate `8 * 5`, which gives us `40 * 10`
 3. Finally, do the last multiplication. The result will be `400`
diff --git a/modules/20-arithmetics/30-composition/es/README.md b/modules/20-arithmetics/30-composition/es/README.md
index 3c3b106f..7ae5ea87 100644
--- a/modules/20-arithmetics/30-composition/es/README.md
+++ b/modules/20-arithmetics/30-composition/es/README.md
@@ -12,8 +12,6 @@ Otra ejemplo:
 console.log(2 * 4 * 5 * 10);
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-composition
-
 Como puedes ver, las operaciones se pueden combinar entre sí, lo que nos permite calcular expresiones compuestas más complejas. Para entender cómo se realizan los cálculos dentro del intérprete, analicemos el ejemplo: `2 * 4 * 5 * 10`.
 
 1. Primero se calcula `2 * 4` y se obtiene la expresión `8 * 5 * 10`.
diff --git a/modules/20-arithmetics/30-composition/ru/README.md b/modules/20-arithmetics/30-composition/ru/README.md
index 3d6b3171..567335a1 100644
--- a/modules/20-arithmetics/30-composition/ru/README.md
+++ b/modules/20-arithmetics/30-composition/ru/README.md
@@ -12,8 +12,6 @@ console.log(3 * 5 - 2); // => 13
 console.log(2 * 4 * 5 * 10);
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-composition
-
 Как видно, операции можно соединять друг с другом, получая возможность вычислять все более сложные составные выражения. Чтобы представить себе то, как происходят вычисления внутри интерпретатора, давайте разберем пример: `2 * 4 * 5 * 10`.
 
 1. Сначала вычисляется `2 * 4` и получается выражение `8 * 5 * 10`.
diff --git a/modules/20-arithmetics/40-priority/description.es.yml b/modules/20-arithmetics/40-priority/description.es.yml
index d8df42b6..e56699fc 100644
--- a/modules/20-arithmetics/40-priority/description.es.yml
+++ b/modules/20-arithmetics/40-priority/description.es.yml
@@ -31,7 +31,6 @@ theory: |
   console.log(((8 / 2) + 5) - (-3 / 2)); // => 10.5
   ```
 
-  https://replit.com/@hexlet/js-basics-arithmetics#index.js
 
   Recuerda: el código se escribe para las personas, porque son personas las que leerán el código y las máquinas solamente lo ejecutarán. Para las máquinas, el código es correcto o incorrecto, no hay código "más" o "menos" comprensible para ellas.
 
diff --git a/modules/20-arithmetics/40-priority/es/README.md b/modules/20-arithmetics/40-priority/es/README.md
index 8d7ab3aa..f784cfa8 100644
--- a/modules/20-arithmetics/40-priority/es/README.md
+++ b/modules/20-arithmetics/40-priority/es/README.md
@@ -27,6 +27,4 @@ Después:
 console.log(((8 / 2) + 5) - (-3 / 2)); // => 10.5
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics#index.js
-
 Recuerda: el código se escribe para las personas, porque son personas las que leerán el código y las máquinas solamente lo ejecutarán. Para las máquinas, el código es correcto o incorrecto, no hay código "más" o "menos" comprensible para ellas.
diff --git a/modules/20-arithmetics/40-priority/ru/README.md b/modules/20-arithmetics/40-priority/ru/README.md
index 2eaa2085..0129307f 100644
--- a/modules/20-arithmetics/40-priority/ru/README.md
+++ b/modules/20-arithmetics/40-priority/ru/README.md
@@ -27,6 +27,4 @@ console.log(8 / 2 + 5 - -3 / 2); // => 10.5
 console.log(((8 / 2) + 5) - (-3 / 2)); // => 10.5
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics#index.js
-
 Запомните: код пишется для людей, потому что код будут читать люди, а машины будут только исполнять его. Для машин код — или корректный, или не корректный, для них нет «более» понятного или «менее» понятного кода.
diff --git a/modules/20-arithmetics/60-infinity/description.es.yml b/modules/20-arithmetics/60-infinity/description.es.yml
index c4b64b4e..aa8b4e0d 100644
--- a/modules/20-arithmetics/60-infinity/description.es.yml
+++ b/modules/20-arithmetics/60-infinity/description.es.yml
@@ -10,7 +10,6 @@ theory: |
   console.log(1 / 0); // ?
   ```
 
-  https://replit.com/@hexlet/js-basics-arithmetics-inifinity
 
   Intenta ejecutar este código en tu navegador. ¡Se mostrará en pantalla `Infinity` (infinito)! Para aquellos que han estudiado matemáticas avanzadas (¡hola, cálculo!), esto no es sorprendente. La división por cero realmente da infinito. En JavaScript, el infinito es un número real con el que se pueden realizar diversas operaciones. En tareas cotidianas, esto tiene poco sentido, ya que la mayoría de las operaciones con infinito resultan en infinito, por ejemplo, al sumar cualquier número a infinito, aún obtendremos infinito.
 
diff --git a/modules/20-arithmetics/60-infinity/es/README.md b/modules/20-arithmetics/60-infinity/es/README.md
index 75e8136f..a2bdac62 100644
--- a/modules/20-arithmetics/60-infinity/es/README.md
+++ b/modules/20-arithmetics/60-infinity/es/README.md
@@ -5,8 +5,6 @@ En programación, es ampliamente conocido el error de "división por cero". En l
 console.log(1 / 0); // ?
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-inifinity
-
 Intenta ejecutar este código en tu navegador. ¡Se mostrará en pantalla `Infinity` (infinito)! Para aquellos que han estudiado matemáticas avanzadas (¡hola, cálculo!), esto no es sorprendente. La división por cero realmente da infinito. En JavaScript, el infinito es un número real con el que se pueden realizar diversas operaciones. En tareas cotidianas, esto tiene poco sentido, ya que la mayoría de las operaciones con infinito resultan en infinito, por ejemplo, al sumar cualquier número a infinito, aún obtendremos infinito.
 
 ```javascript
diff --git a/modules/20-arithmetics/60-infinity/ru/README.md b/modules/20-arithmetics/60-infinity/ru/README.md
index 077f64f9..72beff16 100644
--- a/modules/20-arithmetics/60-infinity/ru/README.md
+++ b/modules/20-arithmetics/60-infinity/ru/README.md
@@ -5,8 +5,6 @@
 console.log(1 / 0); // ?
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-inifinity
-
 Попробуйте выполнить этот код в браузере. На экран выведется `Infinity` (бесконечность)! Для тех, кто изучал высшую математику (привет, матан!), в этом нет ничего удивительного. Деление на ноль действительно создает бесконечность. Бесконечность в JavaScript — самое настоящее число, с которым возможно проводить различные операции. В повседневных задачах смысла от этого мало, так как большинство операций с бесконечностью завершаются созданием бесконечности, например, при прибавлении любого числа к бесконечности мы все равно получим бесконечность.
 
 ```javascript
diff --git a/modules/20-arithmetics/70-nan/description.es.yml b/modules/20-arithmetics/70-nan/description.es.yml
index 0fe37658..e9d7e155 100644
--- a/modules/20-arithmetics/70-nan/description.es.yml
+++ b/modules/20-arithmetics/70-nan/description.es.yml
@@ -15,7 +15,6 @@ theory: |
   NaN + 1; // NaN
   ```
 
-  https://replit.com/@hexlet/js-basics-arithmetics-NaN
 
   `NaN` es un valor interesante, aunque representa "no es un número", desde el punto de vista de los tipos, es considerado un número. Un paradoja. `NaN` nunca es un valor deseado y solamente aparece como resultado de errores. Si te encuentras con él, debes rastrear el momento en el que se realizó una operación no válida para los números y corregir ese espacio.
 
diff --git a/modules/20-arithmetics/70-nan/es/README.md b/modules/20-arithmetics/70-nan/es/README.md
index 5912af4d..ec039017 100644
--- a/modules/20-arithmetics/70-nan/es/README.md
+++ b/modules/20-arithmetics/70-nan/es/README.md
@@ -10,6 +10,4 @@ Infinity / Infinity; // NaN
 NaN + 1; // NaN
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-NaN
-
 `NaN` es un valor interesante, aunque representa "no es un número", desde el punto de vista de los tipos, es considerado un número. Un paradoja. `NaN` nunca es un valor deseado y solamente aparece como resultado de errores. Si te encuentras con él, debes rastrear el momento en el que se realizó una operación no válida para los números y corregir ese espacio.
diff --git a/modules/20-arithmetics/70-nan/ru/README.md b/modules/20-arithmetics/70-nan/ru/README.md
index 64c0cc75..eb4e1283 100644
--- a/modules/20-arithmetics/70-nan/ru/README.md
+++ b/modules/20-arithmetics/70-nan/ru/README.md
@@ -10,6 +10,4 @@ Infinity / Infinity; // NaN
 NaN + 1; // NaN
 ```
 
-https://replit.com/@hexlet/js-basics-arithmetics-NaN
-
 `NaN` интересное значение, хотя оно обозначает "не число" — с точки зрения типов, оно является числом. Парадокс. `NaN` никогда не является желаемым значением и появляется только в результате ошибок. Если вы его встретили, то нужно отследить момент, в котором выполнилась операция, недопустимая для чисел, и поправить это место.
diff --git a/modules/25-strings/15-escape-characters/description.es.yml b/modules/25-strings/15-escape-characters/description.es.yml
index 2789155d..16a14100 100644
--- a/modules/25-strings/15-escape-characters/description.es.yml
+++ b/modules/25-strings/15-escape-characters/description.es.yml
@@ -145,7 +145,4 @@ definitions:
     description: |
       una combinación especial de caracteres en un texto. Por ejemplo, `\n` es un salto de línea.
 
-tips:
-  - |
-    Asegúrate de experimentar con la impresión de diferentes cadenas en el sitio [https://replit.com/languages/nodejs](https://replit.com/languages/nodejs)
-  - |
+tips: []
diff --git a/modules/25-strings/15-escape-characters/en/data.yml b/modules/25-strings/15-escape-characters/en/data.yml
index b5edfa08..84169d63 100644
--- a/modules/25-strings/15-escape-characters/en/data.yml
+++ b/modules/25-strings/15-escape-characters/en/data.yml
@@ -6,9 +6,6 @@ definitions:
       is a special combination of characters in the text. For example, `\n` is a
       line feed.
 tips:
-  - >
-    Be sure to experiment with the output of different strings on
-    [https://replit.com/languages/nodejs](https://replit.com/languages/nodejs)
   - >
     [The History of
     Newline](https://en.wikipedia.org/wiki/Newline#:~:text=External%20links-,History,-%5Bedit%5D)
diff --git a/modules/25-strings/15-escape-characters/es/data.yml b/modules/25-strings/15-escape-characters/es/data.yml
index 12566799..ff48e086 100644
--- a/modules/25-strings/15-escape-characters/es/data.yml
+++ b/modules/25-strings/15-escape-characters/es/data.yml
@@ -5,8 +5,4 @@ definitions:
     description: >
       una combinación especial de caracteres en un texto. Por ejemplo, `\n` es
       un salto de línea.
-tips:
-  - >
-    Asegúrate de experimentar con la impresión de diferentes cadenas en el sitio
-    [https://replit.com/languages/nodejs](https://replit.com/languages/nodejs)
-  - ''
+tips: []
diff --git a/modules/25-strings/15-escape-characters/ru/data.yml b/modules/25-strings/15-escape-characters/ru/data.yml
index 6b1857f5..4556cb70 100644
--- a/modules/25-strings/15-escape-characters/ru/data.yml
+++ b/modules/25-strings/15-escape-characters/ru/data.yml
@@ -6,9 +6,6 @@ definitions:
       специальная комбинация символов в тексте. Например, `\n` — это перевод
       строки.
 tips:
-  - >
-    Обязательно поэкспериментируйте с выводом разных строк на сайте
-    [https://replit.com/languages/nodejs](https://replit.com/languages/nodejs)
   - >
     [История перевода
     строки](https://ru.wikipedia.org/wiki/Перевод_строки#История)
diff --git a/modules/25-strings/20-string-concatenation/description.es.yml b/modules/25-strings/20-string-concatenation/description.es.yml
index 5566c572..bddd1a50 100644
--- a/modules/25-strings/20-string-concatenation/description.es.yml
+++ b/modules/25-strings/20-string-concatenation/description.es.yml
@@ -49,7 +49,6 @@ theory: |
   console.log("King's  " + '  Landing'); // => King's    Landing
   ```
 
-  https://replit.com/@hexlet/js-basics-strings
 
 instructions: |
 
diff --git a/modules/25-strings/20-string-concatenation/en/README.md b/modules/25-strings/20-string-concatenation/en/README.md
index e0342d50..a0e0682a 100644
--- a/modules/25-strings/20-string-concatenation/en/README.md
+++ b/modules/25-strings/20-string-concatenation/en/README.md
@@ -45,5 +45,3 @@ console.log("King's " + ' Landing');   // => King's  Landing
 
 console.log("King's  " + '  Landing'); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/js-basics-strings
diff --git a/modules/25-strings/20-string-concatenation/es/README.md b/modules/25-strings/20-string-concatenation/es/README.md
index 329a484c..314c78ed 100644
--- a/modules/25-strings/20-string-concatenation/es/README.md
+++ b/modules/25-strings/20-string-concatenation/es/README.md
@@ -44,5 +44,3 @@ console.log("King's " + ' Landing');   // => King's  Landing
 
 console.log("King's  " + '  Landing'); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/js-basics-strings
diff --git a/modules/25-strings/20-string-concatenation/ru/README.md b/modules/25-strings/20-string-concatenation/ru/README.md
index cb0721b8..86791ea1 100644
--- a/modules/25-strings/20-string-concatenation/ru/README.md
+++ b/modules/25-strings/20-string-concatenation/ru/README.md
@@ -44,5 +44,3 @@ console.log("King's " + ' Landing');   // => King's  Landing
 
 console.log("King's  " + '  Landing'); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/js-basics-strings
diff --git a/modules/25-strings/30-encoding/description.es.yml b/modules/25-strings/30-encoding/description.es.yml
index 38f42b60..c9ab6a92 100644
--- a/modules/25-strings/30-encoding/description.es.yml
+++ b/modules/25-strings/30-encoding/description.es.yml
@@ -50,7 +50,6 @@ instructions: |
 
   Esto mostrará en pantalla el carácter con el número 63, que es el signo de interrogación `?`. De esta manera, puedes mostrar cualquier carácter.
 
-  https://replit.com/@hexlet/js-basics-strings-encoding
 
   Encuentra una tabla de códigos ASCII en Internet. Puedes usar búsquedas como "tabla de códigos ASCII" o "ascii codes table". Por lo general, en estas tablas los códigos se muestran en varios sistemas de numeración: decimal, binario, octal y hexadecimal. Nos interesa el código decimal (*dec* o *decimal*).
 
diff --git a/modules/25-strings/30-encoding/es/EXERCISE.md b/modules/25-strings/30-encoding/es/EXERCISE.md
index 1f61d33e..63926f17 100644
--- a/modules/25-strings/30-encoding/es/EXERCISE.md
+++ b/modules/25-strings/30-encoding/es/EXERCISE.md
@@ -7,8 +7,6 @@ console.log(String.fromCharCode(63));
 
 Esto mostrará en pantalla el carácter con el número 63, que es el signo de interrogación `?`. De esta manera, puedes mostrar cualquier carácter.
 
-https://replit.com/@hexlet/js-basics-strings-encoding
-
 Encuentra una tabla de códigos ASCII en Internet. Puedes usar búsquedas como "tabla de códigos ASCII" o "ascii codes table". Por lo general, en estas tablas los códigos se muestran en varios sistemas de numeración: decimal, binario, octal y hexadecimal. Nos interesa el código decimal (*dec* o *decimal*).
 
 Utilizando el ejemplo anterior y la tabla que encontraste, muestra en pantalla los caracteres `~`, `^` y `%` (cada uno en su propia línea).
diff --git a/modules/25-strings/30-encoding/ru/EXERCISE.md b/modules/25-strings/30-encoding/ru/EXERCISE.md
index b6e7f9c6..6b072427 100644
--- a/modules/25-strings/30-encoding/ru/EXERCISE.md
+++ b/modules/25-strings/30-encoding/ru/EXERCISE.md
@@ -7,8 +7,6 @@ console.log(String.fromCharCode(63));
 
 На экран выведется символ с номером 63 — вопросительный знак `?`. Таким способом можно выводить любой символ.
 
-https://replit.com/@hexlet/js-basics-strings-encoding
-
 Найдите в интернете таблицу кодов ASCII. Можно использовать запросы типа "ascii codes table" или «коды ascii». Обычно в таких таблицах коды указаны сразу в нескольких системах счисления: десятичной, двоичной, восьмеричной и шестнадцатеричной. Нас интересует десятичный код (*dec* или *decimal*).
 
 Используя пример выше и найденную таблицу, выведите на экран символы `~`, `^` и `%` (каждый на своей собственной строке).
diff --git a/modules/30-variables/10-definition/description.es.yml b/modules/30-variables/10-definition/description.es.yml
index 250ca5e8..4f695ab3 100644
--- a/modules/30-variables/10-definition/description.es.yml
+++ b/modules/30-variables/10-definition/description.es.yml
@@ -48,7 +48,6 @@ theory: |
   console.log(greeting2);
   ```
 
-  https://replit.com/@hexlet/js-basics-variables-definition
 
   Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.
 
diff --git a/modules/30-variables/10-definition/es/README.md b/modules/30-variables/10-definition/es/README.md
index b3d0877f..abe2134d 100644
--- a/modules/30-variables/10-definition/es/README.md
+++ b/modules/30-variables/10-definition/es/README.md
@@ -44,6 +44,4 @@ console.log(greeting2);
 console.log(greeting2);
 ```
 
-https://replit.com/@hexlet/js-basics-variables-definition
-
 Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.
diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md
index 32fa5098..e4802319 100644
--- a/modules/30-variables/10-definition/ru/README.md
+++ b/modules/30-variables/10-definition/ru/README.md
@@ -44,6 +44,4 @@ console.log(greeting2);
 console.log(greeting2);
 ```
 
-https://replit.com/@hexlet/js-basics-variables-definition
-
 Для удобства анализа программы, переменные принято создавать как можно ближе к тому месту, где они используются.
diff --git a/modules/30-variables/11-change/description.es.yml b/modules/30-variables/11-change/description.es.yml
index 36f24fb9..bd990b4d 100644
--- a/modules/30-variables/11-change/description.es.yml
+++ b/modules/30-variables/11-change/description.es.yml
@@ -15,7 +15,6 @@ theory: |
   console.log(greeting);
   ```
 
-  https://replit.com/@hexlet/js-basics-variables-change
 
   El nombre sigue siendo el mismo, pero los datos internos son diferentes. Presta atención a la diferencia clave entre la declaración de una variable y su cambio. La palabra clave `let` solo se utiliza al crear una variable, pero no se utiliza al cambiarla.
 
diff --git a/modules/30-variables/11-change/es/README.md b/modules/30-variables/11-change/es/README.md
index ab908553..d6b64e92 100644
--- a/modules/30-variables/11-change/es/README.md
+++ b/modules/30-variables/11-change/es/README.md
@@ -11,6 +11,4 @@ console.log(greeting);
 console.log(greeting);
 ```
 
-https://replit.com/@hexlet/js-basics-variables-change
-
 El nombre sigue siendo el mismo, pero los datos internos son diferentes. Presta atención a la diferencia clave entre la declaración de una variable y su cambio. La palabra clave `let` solo se utiliza al crear una variable, pero no se utiliza al cambiarla.
diff --git a/modules/30-variables/11-change/ru/README.md b/modules/30-variables/11-change/ru/README.md
index cf430d23..38e227b1 100644
--- a/modules/30-variables/11-change/ru/README.md
+++ b/modules/30-variables/11-change/ru/README.md
@@ -11,6 +11,4 @@ console.log(greeting);
 console.log(greeting);
 ```
 
-https://replit.com/@hexlet/js-basics-variables-change
-
 Имя осталось тем же, но внутри другие данные. Обратите внимание на ключевое различие между объявлением переменной и ее изменением. Ключевое слово `let` ставится только при создании переменной, но при изменении оно уже не используется.
diff --git a/modules/30-variables/15-variables-expressions/description.es.yml b/modules/30-variables/15-variables-expressions/description.es.yml
index 04076bf9..b03ed3fe 100644
--- a/modules/30-variables/15-variables-expressions/description.es.yml
+++ b/modules/30-variables/15-variables-expressions/description.es.yml
@@ -36,8 +36,6 @@ theory: |
   console.log(who);
   ```
 
-  Ejecútalo en [repl.it](https://repl.it/languages/javascript) y experimenta.
-
   

   Respuesta
 
diff --git a/modules/30-variables/15-variables-expressions/en/README.md b/modules/30-variables/15-variables-expressions/en/README.md
index 676c4328..1a346ece 100644
--- a/modules/30-variables/15-variables-expressions/en/README.md
+++ b/modules/30-variables/15-variables-expressions/en/README.md
@@ -32,8 +32,6 @@ let who = "dragon's" + 'mother';
 console.log(who);
 ```
 
-Run it on [repl.it](https://repl.it/languages/javascript) and experiment a little with it.
-
 Now, back to our currency program. We'll record the dollar value in yuan as a separate variable. Calculate the value of 50 euros in dollars by multiplying them by `1.25`. Suppose that 1 dollar is 6.91 yuan:
 
 ```javascript
diff --git a/modules/30-variables/15-variables-expressions/es/README.md b/modules/30-variables/15-variables-expressions/es/README.md
index b81787cb..dfcf4a19 100644
--- a/modules/30-variables/15-variables-expressions/es/README.md
+++ b/modules/30-variables/15-variables-expressions/es/README.md
@@ -32,8 +32,6 @@ let who = "dragon's" + 'mother';
 console.log(who);
 ```
 
-Ejecútalo en [repl.it](https://repl.it/languages/javascript) y experimenta.
-
 

 Respuesta
 
diff --git a/modules/30-variables/15-variables-expressions/ru/README.md b/modules/30-variables/15-variables-expressions/ru/README.md
index 1fe17921..4a3dc145 100644
--- a/modules/30-variables/15-variables-expressions/ru/README.md
+++ b/modules/30-variables/15-variables-expressions/ru/README.md
@@ -32,8 +32,6 @@ let who = "dragon's" + 'mother';
 console.log(who);
 ```
 
-Запустите его на [repl.it](https://repl.it/languages/javascript) и поэкспериментируйте.
-
 

 Ответ
 
diff --git a/modules/30-variables/18-variable-concatenation/description.es.yml b/modules/30-variables/18-variable-concatenation/description.es.yml
index 4ec454bf..cd60c39c 100644
--- a/modules/30-variables/18-variable-concatenation/description.es.yml
+++ b/modules/30-variables/18-variable-concatenation/description.es.yml
@@ -29,7 +29,6 @@ theory: |
   console.log(que); // => Kingsroad
   ```
 
-  https://replit.com/@hexlet/variables-expression
 
 instructions: |
 
diff --git a/modules/30-variables/18-variable-concatenation/en/README.md b/modules/30-variables/18-variable-concatenation/en/README.md
index 6c88d53e..359cf4ca 100644
--- a/modules/30-variables/18-variable-concatenation/en/README.md
+++ b/modules/30-variables/18-variable-concatenation/en/README.md
@@ -24,5 +24,3 @@ let last = 'road';
 let what = first + last;
 console.log(what); // => 'Kingsroad'
 ```
-
-https://replit.com/@hexlet/variables-expression
diff --git a/modules/30-variables/18-variable-concatenation/es/README.md b/modules/30-variables/18-variable-concatenation/es/README.md
index f3209bc4..697f6bde 100644
--- a/modules/30-variables/18-variable-concatenation/es/README.md
+++ b/modules/30-variables/18-variable-concatenation/es/README.md
@@ -24,5 +24,3 @@ let ultimo = 'road';
 let que = primero + ultimo;
 console.log(que); // => Kingsroad
 ```
-
-https://replit.com/@hexlet/variables-expression
diff --git a/modules/30-variables/18-variable-concatenation/ru/README.md b/modules/30-variables/18-variable-concatenation/ru/README.md
index b8508668..1195a2da 100644
--- a/modules/30-variables/18-variable-concatenation/ru/README.md
+++ b/modules/30-variables/18-variable-concatenation/ru/README.md
@@ -24,5 +24,3 @@ let last = 'road';
 let what = first + last;
 console.log(what); // => Kingsroad
 ```
-
-https://replit.com/@hexlet/variables-expression
diff --git a/modules/30-variables/23-constants/description.es.yml b/modules/30-variables/23-constants/description.es.yml
index 3975deef..332f7f4d 100644
--- a/modules/30-variables/23-constants/description.es.yml
+++ b/modules/30-variables/23-constants/description.es.yml
@@ -28,7 +28,6 @@ theory: |
   console.log(rubles);
   ```
 
-  https://replit.com/@hexlet/js-basics-variables
 
   El único cambio es que la palabra clave `let` se ha reemplazado por `const`, pero esto es solo sintaxis. Ahora, si intentamos cambiar cualquier constante, obtendremos un mensaje de error. De lo contrario, se utilizan de la misma manera que las variables.
 
diff --git a/modules/30-variables/23-constants/en/README.md b/modules/30-variables/23-constants/en/README.md
index 12340ad1..a219d205 100644
--- a/modules/30-variables/23-constants/en/README.md
+++ b/modules/30-variables/23-constants/en/README.md
@@ -24,8 +24,6 @@ const rubles = dollars * rublesInDollar; // 75000
 console.log(rubles);
 ```
 
-https://replit.com/@hexlet/js-basics-variables
-
 The only change here is syntactical: the keyword `let` has been replaced by `const`. Now if we try to change any constant, we get an error message. Otherwise, it behaves the same way as a variable.
 
 ```javascript
diff --git a/modules/30-variables/23-constants/es/README.md b/modules/30-variables/23-constants/es/README.md
index 242e34a8..baa9cbcb 100644
--- a/modules/30-variables/23-constants/es/README.md
+++ b/modules/30-variables/23-constants/es/README.md
@@ -24,8 +24,6 @@ const rubles = dollars * rublesInDollar; // 75000
 console.log(rubles);
 ```
 
-https://replit.com/@hexlet/js-basics-variables
-
 El único cambio es que la palabra clave `let` se ha reemplazado por `const`, pero esto es solo sintaxis. Ahora, si intentamos cambiar cualquier constante, obtendremos un mensaje de error. De lo contrario, se utilizan de la misma manera que las variables.
 
 ```javascript
diff --git a/modules/30-variables/23-constants/ru/README.md b/modules/30-variables/23-constants/ru/README.md
index 442d8330..dd31da36 100644
--- a/modules/30-variables/23-constants/ru/README.md
+++ b/modules/30-variables/23-constants/ru/README.md
@@ -24,8 +24,6 @@ const rubles = dollars * rublesInDollar; // 75000
 console.log(rubles);
 ```
 
-https://replit.com/@hexlet/js-basics-variables
-
 Единственное изменение заключается в том, что ключевое слово `let` заменилось на `const`, но это только синтаксис. Теперь, если попытаться изменить любую константу, то мы получим сообщение об ошибке. В остальном они используются точно так же, как и переменные.
 
 ```javascript
diff --git a/modules/30-variables/25-interpolation/description.es.yml b/modules/30-variables/25-interpolation/description.es.yml
index ed775bdf..280ebc36 100644
--- a/modules/30-variables/25-interpolation/description.es.yml
+++ b/modules/30-variables/25-interpolation/description.es.yml
@@ -27,7 +27,6 @@ theory: |
   // => Hello, Joffrey!
   ```
 
-  https://replit.com/@hexlet/js-basics-interpolation
 
   Simplemente creamos una cadena e "insertamos" las constantes en los lugares adecuados utilizando el signo de dólar y las llaves `${ }`. Es como si tuviéramos una plantilla en la que se insertan los valores necesarios. Ya no tenemos que preocuparnos por las cadenas separadas para los signos de puntuación y los espacios: todos estos caracteres están simplemente escritos en esta cadena de plantilla.
 
diff --git a/modules/30-variables/25-interpolation/en/README.md b/modules/30-variables/25-interpolation/en/README.md
index 5191d59c..629bb725 100644
--- a/modules/30-variables/25-interpolation/en/README.md
+++ b/modules/30-variables/25-interpolation/en/README.md
@@ -23,8 +23,6 @@ console.log(`${greeting}, ${firstName}!`);
 // => 'Hello, Joffrey!'
 ```
 
-https://replit.com/@hexlet/js-basics-interpolation
-
 We simply create a string and "insert" constants in proper places using the dollar sign and curly brackets `${ }`. It's like we have a blank form where we can enter the desired values. And we no longer have to worry about separate strings for punctuation marks and spaces – all of these characters already exist in our template string.
 
 You can create as many of these blocks as you want in a single string.
diff --git a/modules/30-variables/25-interpolation/es/README.md b/modules/30-variables/25-interpolation/es/README.md
index b37da8ab..10cd8a44 100644
--- a/modules/30-variables/25-interpolation/es/README.md
+++ b/modules/30-variables/25-interpolation/es/README.md
@@ -23,8 +23,6 @@ console.log(`${greeting}, ${firstName}!`);
 // => Hello, Joffrey!
 ```
 
-https://replit.com/@hexlet/js-basics-interpolation
-
 Simplemente creamos una cadena e "insertamos" las constantes en los lugares adecuados utilizando el signo de dólar y las llaves `${ }`. Es como si tuviéramos una plantilla en la que se insertan los valores necesarios. Ya no tenemos que preocuparnos por las cadenas separadas para los signos de puntuación y los espacios: todos estos caracteres están simplemente escritos en esta cadena de plantilla.
 
 Se pueden hacer tantos bloques similares como se desee en una sola cadena.
diff --git a/modules/30-variables/25-interpolation/ru/README.md b/modules/30-variables/25-interpolation/ru/README.md
index 5f31fd9c..ca629359 100644
--- a/modules/30-variables/25-interpolation/ru/README.md
+++ b/modules/30-variables/25-interpolation/ru/README.md
@@ -23,8 +23,6 @@ console.log(`${greeting}, ${firstName}!`);
 // => Hello, Joffrey!
 ```
 
-https://replit.com/@hexlet/js-basics-interpolation
-
 Мы просто создали одну строку и «вставили» в неё в нужные места константы с помощью знака доллара и фигурных скобок `${ }`. Получился как будто бланк, куда внесены нужные значения. И нам не нужно больше заботиться об отдельных строках для знаков препинания и пробелов — все эти символы просто записаны в этой строке-шаблоне.
 
 В одной строке можно делать сколько угодно подобных блоков.
diff --git a/modules/30-variables/30-symbols/description.es.yml b/modules/30-variables/30-symbols/description.es.yml
index af016384..1a2c457b 100644
--- a/modules/30-variables/30-symbols/description.es.yml
+++ b/modules/30-variables/30-symbols/description.es.yml
@@ -51,7 +51,6 @@ theory: |
   console.log(firstName[10]); // => undefined
   ```
 
-  https://replit.com/@hexlet/js-basics-symbols
 
 instructions: |
 
diff --git a/modules/30-variables/30-symbols/es/README.md b/modules/30-variables/30-symbols/es/README.md
index 6fd8432f..c750266f 100644
--- a/modules/30-variables/30-symbols/es/README.md
+++ b/modules/30-variables/30-symbols/es/README.md
@@ -46,5 +46,3 @@ const firstName = 'Tirion';
 
 console.log(firstName[10]); // => undefined
 ```
-
-https://replit.com/@hexlet/js-basics-symbols
diff --git a/modules/30-variables/30-symbols/ru/README.md b/modules/30-variables/30-symbols/ru/README.md
index 6bc82cc9..d12bc68c 100644
--- a/modules/30-variables/30-symbols/ru/README.md
+++ b/modules/30-variables/30-symbols/ru/README.md
@@ -46,5 +46,3 @@ const firstName = 'Tirion';
 
 console.log(firstName[10]); // => undefined
 ```
-
-https://replit.com/@hexlet/js-basics-symbols
diff --git a/modules/33-data-types/10-primitive-data-types/description.es.yml b/modules/33-data-types/10-primitive-data-types/description.es.yml
index 15caa205..905eb636 100644
--- a/modules/33-data-types/10-primitive-data-types/description.es.yml
+++ b/modules/33-data-types/10-primitive-data-types/description.es.yml
@@ -25,7 +25,6 @@ theory: |
   typeof 'Juego'; // string
   ```
 
-  https://replit.com/@hexlet/js-basics-data-types-primitive-data-types
 
   Los tipos de datos Number, BigInt y String son tipos *primitivos*. Pero hay otros. En JavaScript, hay un tipo compuesto llamado Object (y con base en él, arrays, fechas y otros). Con él, se pueden combinar datos de diferentes tipos en un solo valor, por ejemplo, podemos crear un usuario agregando un nombre y una edad.
 
diff --git a/modules/33-data-types/10-primitive-data-types/es/README.md b/modules/33-data-types/10-primitive-data-types/es/README.md
index 9805d61c..1e7b92db 100644
--- a/modules/33-data-types/10-primitive-data-types/es/README.md
+++ b/modules/33-data-types/10-primitive-data-types/es/README.md
@@ -21,8 +21,6 @@ typeof 3; // number
 typeof 'Juego'; // string
 ```
 
-https://replit.com/@hexlet/js-basics-data-types-primitive-data-types
-
 Los tipos de datos Number, BigInt y String son tipos *primitivos*. Pero hay otros. En JavaScript, hay un tipo compuesto llamado Object (y con base en él, arrays, fechas y otros). Con él, se pueden combinar datos de diferentes tipos en un solo valor, por ejemplo, podemos crear un usuario agregando un nombre y una edad.
 
 ```javascript
diff --git a/modules/33-data-types/10-primitive-data-types/ru/README.md b/modules/33-data-types/10-primitive-data-types/ru/README.md
index 3098b110..b5fbe98c 100644
--- a/modules/33-data-types/10-primitive-data-types/ru/README.md
+++ b/modules/33-data-types/10-primitive-data-types/ru/README.md
@@ -21,8 +21,6 @@ typeof 3; // number
 typeof 'Game'; // string
 ```
 
-https://replit.com/@hexlet/js-basics-data-types-primitive-data-types
-
 Типы данных Number, BigInt и String — это *примитивные* типы. Но есть и другие. В JavaScript встроен составной тип Object (а на его базе массивы, даты и другие). С его помощью можно объединять данные разных типов в одно значение, например, мы можем создать пользователя добавив к нему имя и возраст.
 
 ```javascript
diff --git a/modules/33-data-types/45-undefined/description.es.yml b/modules/33-data-types/45-undefined/description.es.yml
index e9fb5c5f..5ae79026 100644
--- a/modules/33-data-types/45-undefined/description.es.yml
+++ b/modules/33-data-types/45-undefined/description.es.yml
@@ -17,8 +17,6 @@ theory: |
   console.log(name[8]);
   ```
 
-  https://replit.com/@hexlet/js-basics-data-types-undefined
-
   El significado (semántica) del valor `undefined` es precisamente que no hay valor. Sin embargo, nada impide escribir este código:
 
   ```javascript
diff --git a/modules/33-data-types/45-undefined/es/README.md b/modules/33-data-types/45-undefined/es/README.md
index b3a347b4..07648dcd 100644
--- a/modules/33-data-types/45-undefined/es/README.md
+++ b/modules/33-data-types/45-undefined/es/README.md
@@ -13,8 +13,6 @@ const name = 'Arya';
 console.log(name[8]);
 ```
 
-https://replit.com/@hexlet/js-basics-data-types-undefined
-
 El significado (semántica) del valor `undefined` es precisamente que no hay valor. Sin embargo, nada impide escribir este código:
 
 ```javascript
diff --git a/modules/33-data-types/45-undefined/ru/README.md b/modules/33-data-types/45-undefined/ru/README.md
index 4bbee238..8bf5ffbb 100644
--- a/modules/33-data-types/45-undefined/ru/README.md
+++ b/modules/33-data-types/45-undefined/ru/README.md
@@ -13,8 +13,6 @@ const name = 'Arya';
 console.log(name[8]);
 ```
 
-https://replit.com/@hexlet/js-basics-data-types-undefined
-
 Смысл (семантика) значения `undefined` именно в том, что значения нет. Однако, ничто не мешает написать такой код:
 
 ```javascript
diff --git a/modules/33-data-types/50-data-types-weak-typing/description.es.yml b/modules/33-data-types/50-data-types-weak-typing/description.es.yml
index 0cf6662d..b180b0da 100644
--- a/modules/33-data-types/50-data-types-weak-typing/description.es.yml
+++ b/modules/33-data-types/50-data-types-weak-typing/description.es.yml
@@ -20,7 +20,6 @@ theory: |
   console.log(result); // => NaN
   ```
 
-  https://replit.com/@hexlet/js-basics-immutability-of-primitive-types
 
   En los lenguajes con **tipado fuerte**, no se puede sumar un número y una cadena de texto.
 
diff --git a/modules/33-data-types/50-data-types-weak-typing/en/README.md b/modules/33-data-types/50-data-types-weak-typing/en/README.md
index a7961b9d..b5738ded 100644
--- a/modules/33-data-types/50-data-types-weak-typing/en/README.md
+++ b/modules/33-data-types/50-data-types-weak-typing/en/README.md
@@ -16,8 +16,6 @@ const result = 'one' * 'two';
 console.log(result); // => NaN
 ```
 
-https://replit.com/@hexlet/js-basics-immutability-of-primitive-types
-
 In **strongly typed** languages, adding a number to a string won't work.
 
 JavaScript was created for the Internet, where all information is stored in strings. Even when you type a phone number or a birth year on a website, that information goes to the server as a string, not as a number. So the designers of the language decided that automatic type conversion is suitable and convenient.
diff --git a/modules/33-data-types/50-data-types-weak-typing/es/README.md b/modules/33-data-types/50-data-types-weak-typing/es/README.md
index baff7b73..405c916e 100644
--- a/modules/33-data-types/50-data-types-weak-typing/es/README.md
+++ b/modules/33-data-types/50-data-types-weak-typing/es/README.md
@@ -16,8 +16,6 @@ const result = 'one' * 'two';
 console.log(result); // => NaN
 ```
 
-https://replit.com/@hexlet/js-basics-immutability-of-primitive-types
-
 En los lenguajes con **tipado fuerte**, no se puede sumar un número y una cadena de texto.
 
 JavaScript fue creado para Internet, y en Internet toda la información es una cadena de texto. Incluso cuando ingresas un número de teléfono o una fecha de nacimiento en un sitio web, esa información llega al servidor como una cadena de texto y no como un número. Por eso, los creadores del lenguaje decidieron que convertir automáticamente los tipos era correcto y conveniente.
diff --git a/modules/33-data-types/50-data-types-weak-typing/ru/README.md b/modules/33-data-types/50-data-types-weak-typing/ru/README.md
index 4fab117c..04f618ed 100644
--- a/modules/33-data-types/50-data-types-weak-typing/ru/README.md
+++ b/modules/33-data-types/50-data-types-weak-typing/ru/README.md
@@ -16,8 +16,6 @@ const result = 'one' * 'two';
 console.log(result); // => NaN
 ```
 
-https://replit.com/@hexlet/js-basics-immutability-of-primitive-types
-
 В языках со **строгой типизацией** сложить число со строкой не получится.
 
 JavaScript был создан для интернета, а в интернете вся информация — это строки. Даже когда вы вводите на сайте номер телефона или год рождения, на сервер эта информация поступает не как числа, а как строки. Поэтому авторы языка решили, что автоматически преобразовывать типы — правильно и удобно.
diff --git a/modules/35-calling-functions/110-math/ru/README.md b/modules/35-calling-functions/110-math/ru/README.md
index b118c7a5..07ba109c 100644
--- a/modules/35-calling-functions/110-math/ru/README.md
+++ b/modules/35-calling-functions/110-math/ru/README.md
@@ -7,8 +7,6 @@
 Math.pow(2, 3); // 8
 ```
 
-https://replit.com/@hexlet/js-basics-calling-functions-math
-
 Что такое `Math`? Технически — это объект, доступный из любого места программы, но перед тем, как говорить об объектах, нужно проделать очень большой путь. Сейчас достаточно запомнить, что функции для математических операций вызываются через `Math.`. Наличие этой приставки никак не влияет на понятие функции, которое мы рассмотрели ранее и будем рассматривать позже.
 
 Полный список функций Math доступен в [документации](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math). О том, как её правильно читать, мы поговорим далее.
diff --git a/modules/35-calling-functions/120-function-signature/description.es.yml b/modules/35-calling-functions/120-function-signature/description.es.yml
index 2f233cb3..78ec8ece 100644
--- a/modules/35-calling-functions/120-function-signature/description.es.yml
+++ b/modules/35-calling-functions/120-function-signature/description.es.yml
@@ -10,7 +10,6 @@ theory: |
   console.log(result); // => NaN
   ```
 
-  https://replit.com/@hexlet/js-basics-calling-functions-function-signature
 
   Otra función puede tener un número diferente de parámetros y diferentes tipos de parámetros. Por ejemplo, puede existir una función que acepte tres parámetros: un número, una cadena y otro número.
 
diff --git a/modules/35-calling-functions/120-function-signature/es/README.md b/modules/35-calling-functions/120-function-signature/es/README.md
index 20562577..53068018 100644
--- a/modules/35-calling-functions/120-function-signature/es/README.md
+++ b/modules/35-calling-functions/120-function-signature/es/README.md
@@ -6,8 +6,6 @@ const result = Math.pow(2, 'boom');
 console.log(result); // => NaN
 ```
 
-https://replit.com/@hexlet/js-basics-calling-functions-function-signature
-
 Otra función puede tener un número diferente de parámetros y diferentes tipos de parámetros. Por ejemplo, puede existir una función que acepte tres parámetros: un número, una cadena y otro número.
 
 ¿De dónde sabemos cuántos y qué tipo de parámetros necesita la función `Math.pow()` y qué tipo de valor devuelve? Miramos la **firma** de esta función. La firma define los parámetros de entrada y sus tipos, así como el parámetro de salida y su tipo. Puedes leer sobre la función `Math.pow()` en la [documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Math/pow). En la sección "Sintaxis" se encuentra el siguiente texto:
diff --git a/modules/35-calling-functions/120-function-signature/ru/README.md b/modules/35-calling-functions/120-function-signature/ru/README.md
index b7cd1d2b..5c1ca3b4 100644
--- a/modules/35-calling-functions/120-function-signature/ru/README.md
+++ b/modules/35-calling-functions/120-function-signature/ru/README.md
@@ -6,8 +6,6 @@ const result = Math.pow(2, 'boom');
 console.log(result); // => NaN
 ```
 
-https://replit.com/@hexlet/js-basics-calling-functions-function-signature
-
 Другая функция может иметь другое число параметров и другие типы параметров. Например, может существовать функция, которая принимает три параметра: число, строку и ещё одно число.
 
 Откуда мы знаем, сколько каких параметров нужно функции `Math.pow()` и какого типа будет «возврат»? Мы заглянули в **сигнатуру** этой функции. Сигнатура определяет входные параметры и их типы, а также выходной параметр и его тип. Про функцию `Math.pow()` можно почитать в [документации](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/pow). В разделе «Синтаксис» есть такой текст:
diff --git a/modules/35-calling-functions/270-deterministic/en/EXERCISE.md b/modules/35-calling-functions/270-deterministic/en/EXERCISE.md
index fb31f2cf..1df1191b 100644
--- a/modules/35-calling-functions/270-deterministic/en/EXERCISE.md
+++ b/modules/35-calling-functions/270-deterministic/en/EXERCISE.md
@@ -1,7 +1,5 @@
 
 The function `Math.random()` returns a random number from 0 to 1 with many decimal places. But in real tasks, you sometimes want to get random integers, for example, a random number 0 to 10. Write a program printing specifically those numbers. To solve it you'll need [Math.random()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) and [Math.round()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round).
-
-
 Try to solve this task using only 1 line.
 
 ## Algorithm
diff --git a/modules/38-properties/100-properties-syntax/description.es.yml b/modules/38-properties/100-properties-syntax/description.es.yml
index 5bc2f3a2..36624b63 100644
--- a/modules/38-properties/100-properties-syntax/description.es.yml
+++ b/modules/38-properties/100-properties-syntax/description.es.yml
@@ -20,7 +20,6 @@ theory: |
   console.log(len); // => 4
   ```
 
-  https://replit.com/@hexlet/js-basics-properties-properties-syntax
 
   Las propiedades están asociadas a los datos de los que se obtienen. Para los tipos de datos primitivos, todas las propiedades están documentadas, como por ejemplo, las [cadenas de texto](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String). Sin embargo, los números no tienen propiedades.
 
diff --git a/modules/38-properties/100-properties-syntax/es/README.md b/modules/38-properties/100-properties-syntax/es/README.md
index 67433406..9dc4a3f2 100644
--- a/modules/38-properties/100-properties-syntax/es/README.md
+++ b/modules/38-properties/100-properties-syntax/es/README.md
@@ -16,8 +16,6 @@ const len = name.length;
 console.log(len); // => 4
 ```
 
-https://replit.com/@hexlet/js-basics-properties-properties-syntax
-
 Las propiedades están asociadas a los datos de los que se obtienen. Para los tipos de datos primitivos, todas las propiedades están documentadas, como por ejemplo, las [cadenas de texto](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String). Sin embargo, los números no tienen propiedades.
 
 JavaScript permite acceder a propiedades que no existen (por ejemplo, debido a errores de escritura). En este caso, el valor de esas propiedades es `undefined`:
diff --git a/modules/38-properties/100-properties-syntax/ru/README.md b/modules/38-properties/100-properties-syntax/ru/README.md
index 49cd3abd..a8bf6e8e 100644
--- a/modules/38-properties/100-properties-syntax/ru/README.md
+++ b/modules/38-properties/100-properties-syntax/ru/README.md
@@ -16,8 +16,6 @@ const len = name.length;
 console.log(len); // => 4
 ```
 
-https://replit.com/@hexlet/js-basics-properties-properties-syntax
-
 Свойства связаны с данными, у которых они берутся. Для примитивных типов все свойства описаны в документации, как например, у [строк](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String). При этом у чисел вообще нет свойств.
 
 JavaScript позволяет обращаться к свойствам, которые не существуют (например, при опечатках). В таком случае их значением является `undefined`:
diff --git a/modules/38-properties/200-properties-methods/description.es.yml b/modules/38-properties/200-properties-methods/description.es.yml
index 7ae26379..cb9ff512 100644
--- a/modules/38-properties/200-properties-methods/description.es.yml
+++ b/modules/38-properties/200-properties-methods/description.es.yml
@@ -11,7 +11,6 @@ theory: |
   console.log(upperName); // => ROBB
   ```
 
-  https://replit.com/@hexlet/js-basics-properties-methods
 
   Los métodos incorporados siempre operan en los datos con los que están asociados. El método `.toUpperCase()` devuelve la misma cadena, pero convierte todos los caracteres a mayúsculas. Por lo general, hay muchos más métodos que propiedades para los datos, por ejemplo, para las cadenas hay [varias docenas](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String). A primera vista, en la documentación se describen de manera un poco extraña: *String.prototype.toLowerCase()*. Esta descripción revela algunos detalles internos  de implementación que no son importantes en este momento, y tampoco hemos estudiado toda la base necesaria para hablar sobre los prototipos.
 
diff --git a/modules/38-properties/200-properties-methods/es/README.md b/modules/38-properties/200-properties-methods/es/README.md
index c3b48333..d4665122 100644
--- a/modules/38-properties/200-properties-methods/es/README.md
+++ b/modules/38-properties/200-properties-methods/es/README.md
@@ -7,8 +7,6 @@ const upperName = name.toUpperCase();
 console.log(upperName); // => ROBB
 ```
 
-https://replit.com/@hexlet/js-basics-properties-methods
-
 Los métodos incorporados siempre operan en los datos con los que están asociados. El método `.toUpperCase()` devuelve la misma cadena, pero convierte todos los caracteres a mayúsculas. Por lo general, hay muchos más métodos que propiedades para los datos, por ejemplo, para las cadenas hay [varias docenas](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String). A primera vista, en la documentación se describen de manera un poco extraña: *String.prototype.toLowerCase()*. Esta descripción revela algunos detalles internos  de implementación que no son importantes en este momento, y tampoco hemos estudiado toda la base necesaria para hablar sobre los prototipos.
 
 Los números también tienen métodos, como se muestra en [este enlace](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Number):
diff --git a/modules/38-properties/200-properties-methods/ru/README.md b/modules/38-properties/200-properties-methods/ru/README.md
index be3f4142..66c81485 100644
--- a/modules/38-properties/200-properties-methods/ru/README.md
+++ b/modules/38-properties/200-properties-methods/ru/README.md
@@ -7,8 +7,6 @@ const upperName = name.toUpperCase();
 console.log(upperName); // => ROBB
 ```
 
-https://replit.com/@hexlet/js-basics-properties-methods
-
 Встроенные методы всегда оперируют теми данными, с которыми они связаны. Метод `.toUpperCase()` возвращает ту же строку, но преобразуя все символы в верхний регистр. Методов у данных обычно значительно больше, чем свойств, например, для строк их [несколько десятков](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String). В документации, на первый взгляд, они описаны немного странно: *String.prototype.toLowerCase()*. Это описание раскрывает некоторые внутренние детали реализации, которые сейчас не важны, да и мы не изучили всей необходимой базы для разговора о прототипах.
 
 Методы есть и у [чисел](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Number):
diff --git a/modules/38-properties/300-properties-immutability/description.es.yml b/modules/38-properties/300-properties-immutability/description.es.yml
index 2bea3a67..65bdee1f 100644
--- a/modules/38-properties/300-properties-immutability/description.es.yml
+++ b/modules/38-properties/300-properties-immutability/description.es.yml
@@ -20,7 +20,6 @@ theory: |
   console.log(name.length); // => 6
   ```
 
-  https://replit.com/@hexlet/js-properties-immutability
 
   En lugar de cambiar el valor, se puede *reemplazar* el valor. Para ello, se necesitarán variables:
 
diff --git a/modules/38-properties/300-properties-immutability/es/README.md b/modules/38-properties/300-properties-immutability/es/README.md
index 1d150350..e57416ee 100644
--- a/modules/38-properties/300-properties-immutability/es/README.md
+++ b/modules/38-properties/300-properties-immutability/es/README.md
@@ -16,8 +16,6 @@ name.length = 100;
 console.log(name.length); // => 6
 ```
 
-https://replit.com/@hexlet/js-properties-immutability
-
 En lugar de cambiar el valor, se puede *reemplazar* el valor. Para ello, se necesitarán variables:
 
 ```javascript
diff --git a/modules/38-properties/300-properties-immutability/ru/README.md b/modules/38-properties/300-properties-immutability/ru/README.md
index a73d9e58..3427a789 100644
--- a/modules/38-properties/300-properties-immutability/ru/README.md
+++ b/modules/38-properties/300-properties-immutability/ru/README.md
@@ -16,8 +16,6 @@ name.length = 100;
 console.log(name.length); // => 6
 ```
 
-https://replit.com/@hexlet/js-properties-immutability
-
 Вместо изменения значения можно *заменить* значение. Для этого понадобятся переменные:
 
 ```javascript
diff --git a/modules/38-properties/400-properties-expressions/description.es.yml b/modules/38-properties/400-properties-expressions/description.es.yml
index 6863dff3..28b42fa5 100644
--- a/modules/38-properties/400-properties-expressions/description.es.yml
+++ b/modules/38-properties/400-properties-expressions/description.es.yml
@@ -23,7 +23,6 @@ theory: |
   console.log(Math.min(name1.length, name2.length)); // => 4
   ```
 
-  https://replit.com/@hexlet/js-basics-properties-method
 
 instructions: |
 
diff --git a/modules/38-properties/400-properties-expressions/en/README.md b/modules/38-properties/400-properties-expressions/en/README.md
index 480f3dad..84a68e7f 100644
--- a/modules/38-properties/400-properties-expressions/en/README.md
+++ b/modules/38-properties/400-properties-expressions/en/README.md
@@ -18,5 +18,3 @@ console.log(name2.length); // => 5
 console.log(name2.toLowerCase()); // => shaya
 console.log(Math.min(name1.length, name2.length)); // => 4
 ```
-
-https://replit.com/@hexlet/js-basics-properties-method
diff --git a/modules/38-properties/400-properties-expressions/es/README.md b/modules/38-properties/400-properties-expressions/es/README.md
index 4dc4366e..02b21da0 100644
--- a/modules/38-properties/400-properties-expressions/es/README.md
+++ b/modules/38-properties/400-properties-expressions/es/README.md
@@ -18,5 +18,3 @@ console.log(name2.length); // => 5
 console.log(name2.toLowerCase()); // => shaya
 console.log(Math.min(name1.length, name2.length)); // => 4
 ```
-
-https://replit.com/@hexlet/js-basics-properties-method
diff --git a/modules/38-properties/400-properties-expressions/ru/README.md b/modules/38-properties/400-properties-expressions/ru/README.md
index 95a1b91f..efe722c9 100644
--- a/modules/38-properties/400-properties-expressions/ru/README.md
+++ b/modules/38-properties/400-properties-expressions/ru/README.md
@@ -18,5 +18,3 @@ console.log(name2.length); // => 5
 console.log(name2.toLowerCase()); // => shaya
 console.log(Math.min(name1.length, name2.length)); // => 4
 ```
-
-https://replit.com/@hexlet/js-basics-properties-method
diff --git a/modules/40-define-functions/100-define-functions-syntax/description.es.yml b/modules/40-define-functions/100-define-functions-syntax/description.es.yml
index 45276c55..2d71baf7 100644
--- a/modules/40-define-functions/100-define-functions-syntax/description.es.yml
+++ b/modules/40-define-functions/100-define-functions-syntax/description.es.yml
@@ -38,7 +38,6 @@ theory: |
   showGreeting(); // => Hello, Hexlet!
   ```
 
-  https://replit.com/@hexlet/js-basics-functions-define
 
   A diferencia de los datos normales, las funciones realizan acciones, por lo que sus nombres casi siempre deben ser verbos: "construir algo", "dibujar algo", "abrir algo".
 
diff --git a/modules/40-define-functions/100-define-functions-syntax/en/README.md b/modules/40-define-functions/100-define-functions-syntax/en/README.md
index d253c875..0440007f 100644
--- a/modules/40-define-functions/100-define-functions-syntax/en/README.md
+++ b/modules/40-define-functions/100-define-functions-syntax/en/README.md
@@ -34,8 +34,6 @@ const showGreeting = () => {
 showGreeting(); // => "Hello, Hexlet!"
 ```
 
-https://replit.com/@hexlet/js-basics-functions-define
-
 Unlike normal data, functions perform actions, so their names almost always have to be verbs: "build something", "draw something", "open something", etc.
 
 Anything described inside the curly brackets `{}` is called a function body. It can contain any code. Consider it a small independent program, a set of arbitrary statements. The body is executed precisely when the function is called. And each function call executes the body independently of other calls. By the way, the body can be empty:
diff --git a/modules/40-define-functions/100-define-functions-syntax/es/README.md b/modules/40-define-functions/100-define-functions-syntax/es/README.md
index 4eb6a526..236237a1 100644
--- a/modules/40-define-functions/100-define-functions-syntax/es/README.md
+++ b/modules/40-define-functions/100-define-functions-syntax/es/README.md
@@ -34,8 +34,6 @@ const showGreeting = () => {
 showGreeting(); // => Hello, Hexlet!
 ```
 
-https://replit.com/@hexlet/js-basics-functions-define
-
 A diferencia de los datos normales, las funciones realizan acciones, por lo que sus nombres casi siempre deben ser verbos: "construir algo", "dibujar algo", "abrir algo".
 
 Todo lo que se describe dentro de las llaves `{}` se llama cuerpo de la función. Dentro del cuerpo se puede escribir cualquier código. Considéralo como un pequeño programa independiente, un conjunto de instrucciones arbitrarias. El cuerpo se ejecuta exactamente en el momento en que se ejecuta la función. Además, cada llamada a la función ejecuta el cuerpo de forma independiente de otras llamadas. Por cierto, el cuerpo puede estar vacío:
diff --git a/modules/40-define-functions/100-define-functions-syntax/ru/README.md b/modules/40-define-functions/100-define-functions-syntax/ru/README.md
index bc9d7922..4dd4dae3 100644
--- a/modules/40-define-functions/100-define-functions-syntax/ru/README.md
+++ b/modules/40-define-functions/100-define-functions-syntax/ru/README.md
@@ -34,8 +34,6 @@ const showGreeting = () => {
 showGreeting(); // => Hello, Hexlet!
 ```
 
-https://replit.com/@hexlet/js-basics-functions-define
-
 В отличие от обычных данных, функции выполняют действия, поэтому их имена практически всегда должны быть глаголами: «построить что-то», «нарисовать что-то», «открыть что-то».
 
 Всё, что описывается внутри фигурных скобок `{}`, называется телом функции. Внутри тела можно описывать любой код. Считайте, что это маленькая самостоятельная программа, набор произвольных инструкций. Тело выполняется ровно в тот момент, когда запускается функция. Причём каждый вызов функции запускает тело независимо от других вызовов. Кстати, тело может быть пустым:
diff --git a/modules/40-define-functions/150-define-functions-return/description.es.yml b/modules/40-define-functions/150-define-functions-return/description.es.yml
index 4c90585b..2c6879ce 100644
--- a/modules/40-define-functions/150-define-functions-return/description.es.yml
+++ b/modules/40-define-functions/150-define-functions-return/description.es.yml
@@ -117,7 +117,6 @@ theory: |
 
   

 
-  https://replit.com/@hexlet/js-basics-functions-return
 
 instructions: |
 
diff --git a/modules/40-define-functions/150-define-functions-return/en/README.md b/modules/40-define-functions/150-define-functions-return/en/README.md
index 9e588aaf..ca8594c7 100644
--- a/modules/40-define-functions/150-define-functions-return/en/README.md
+++ b/modules/40-define-functions/150-define-functions-return/en/README.md
@@ -64,5 +64,3 @@ const run = () => {
 // Usage
 run(); // => ?
 ```
-
-https://replit.com/@hexlet/js-basics-functions-return
diff --git a/modules/40-define-functions/150-define-functions-return/es/README.md b/modules/40-define-functions/150-define-functions-return/es/README.md
index 98327d82..8491843c 100644
--- a/modules/40-define-functions/150-define-functions-return/es/README.md
+++ b/modules/40-define-functions/150-define-functions-return/es/README.md
@@ -112,5 +112,3 @@ console.log(run());
 En la pantalla se imprimirá `5`.
 
 

-
-https://replit.com/@hexlet/js-basics-functions-return
diff --git a/modules/40-define-functions/150-define-functions-return/ru/README.md b/modules/40-define-functions/150-define-functions-return/ru/README.md
index 7c7cf145..7e2f6aa1 100644
--- a/modules/40-define-functions/150-define-functions-return/ru/README.md
+++ b/modules/40-define-functions/150-define-functions-return/ru/README.md
@@ -112,5 +112,3 @@ console.log(run());
 На экран будет выведено `5`.
 
 

-
-https://replit.com/@hexlet/js-basics-functions-return
diff --git a/modules/40-define-functions/320-define-functions-parameters/description.es.yml b/modules/40-define-functions/320-define-functions-parameters/description.es.yml
index 43621d76..098c8621 100644
--- a/modules/40-define-functions/320-define-functions-parameters/description.es.yml
+++ b/modules/40-define-functions/320-define-functions-parameters/description.es.yml
@@ -78,7 +78,6 @@ theory: |
   average(1, 2); // 1.5
   ```
 
-  https://replit.com/@hexlet/js-basics-define-functions-parameters
 
   Lo mismo se aplica a los métodos. Pueden requerir cualquier cantidad de parámetros que necesiten para funcionar:
 
diff --git a/modules/40-define-functions/320-define-functions-parameters/es/README.md b/modules/40-define-functions/320-define-functions-parameters/es/README.md
index 8316bad4..eff8b948 100644
--- a/modules/40-define-functions/320-define-functions-parameters/es/README.md
+++ b/modules/40-define-functions/320-define-functions-parameters/es/README.md
@@ -74,8 +74,6 @@ average(1, 5); // 3
 average(1, 2); // 1.5
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-parameters
-
 Lo mismo se aplica a los métodos. Pueden requerir cualquier cantidad de parámetros que necesiten para funcionar:
 
 ```javascript
diff --git a/modules/40-define-functions/320-define-functions-parameters/ru/README.md b/modules/40-define-functions/320-define-functions-parameters/ru/README.md
index f1e2853b..6dbcafdd 100644
--- a/modules/40-define-functions/320-define-functions-parameters/ru/README.md
+++ b/modules/40-define-functions/320-define-functions-parameters/ru/README.md
@@ -74,8 +74,6 @@ average(1, 5); // 3
 average(1, 2); // 1.5
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-parameters
-
 То же самое относится и к методам. Они могут требовать на вход любое количество параметров, которое им нужно для работы:
 
 ```javascript
diff --git a/modules/40-define-functions/340-define-functions-default-parameters/description.es.yml b/modules/40-define-functions/340-define-functions-default-parameters/description.es.yml
index 0ceac7e4..e8b152a8 100644
--- a/modules/40-define-functions/340-define-functions-default-parameters/description.es.yml
+++ b/modules/40-define-functions/340-define-functions-default-parameters/description.es.yml
@@ -17,7 +17,6 @@ theory: |
   pow(3, 3); // 27
   ```
 
-  https://replit.com/@hexlet/js-basics-define-functions-default-parameters
 
   El valor predeterminado se ve como una asignación normal en la definición. Solamente se activa si el argumento no se pasa. Hay que acostumbrarse a esto. El valor predeterminado incluso puede estar presente cuando solo hay un parámetro:
 
diff --git a/modules/40-define-functions/340-define-functions-default-parameters/es/README.md b/modules/40-define-functions/340-define-functions-default-parameters/es/README.md
index b9364ceb..56057f53 100644
--- a/modules/40-define-functions/340-define-functions-default-parameters/es/README.md
+++ b/modules/40-define-functions/340-define-functions-default-parameters/es/README.md
@@ -13,8 +13,6 @@ pow(3); // 9
 pow(3, 3); // 27
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-default-parameters
-
 El valor predeterminado se ve como una asignación normal en la definición. Solamente se activa si el argumento no se pasa. Hay que acostumbrarse a esto. El valor predeterminado incluso puede estar presente cuando solo hay un parámetro:
 
 ```javascript
diff --git a/modules/40-define-functions/340-define-functions-default-parameters/ru/README.md b/modules/40-define-functions/340-define-functions-default-parameters/ru/README.md
index b81d72fa..b66fabdf 100644
--- a/modules/40-define-functions/340-define-functions-default-parameters/ru/README.md
+++ b/modules/40-define-functions/340-define-functions-default-parameters/ru/README.md
@@ -13,8 +13,6 @@ pow(3); // 9
 pow(3, 3); // 27
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-default-parameters
-
 Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если аргумент не передан. К этому нужно привыкнуть. Значение по умолчанию может быть даже в том случае, когда параметр один:
 
 ```javascript
diff --git a/modules/40-define-functions/450-define-functions-short-syntax/description.es.yml b/modules/40-define-functions/450-define-functions-short-syntax/description.es.yml
index 282a3bdf..78bfd0f9 100644
--- a/modules/40-define-functions/450-define-functions-short-syntax/description.es.yml
+++ b/modules/40-define-functions/450-define-functions-short-syntax/description.es.yml
@@ -37,7 +37,6 @@ theory: |
   const sum = (a, b) => a + b;
   ```
 
-  https://replit.com/@hexlet/js-basics-define-functions-short-syntax
 
   Ten en cuenta la ausencia de las llaves. Los desarrolladores que no están acostumbrados a este tipo de sintaxis a veces escriben código como `const sum = (a, b) => { a + b };` y luego se preguntan por qué no funciona. La respuesta es simple: si hay llaves, entonces no se está usando la forma simplificada y tendrás que agregar la palabra `return` para que la función devuelva un valor.
 
diff --git a/modules/40-define-functions/450-define-functions-short-syntax/es/README.md b/modules/40-define-functions/450-define-functions-short-syntax/es/README.md
index 77db5f2f..81eaf2eb 100644
--- a/modules/40-define-functions/450-define-functions-short-syntax/es/README.md
+++ b/modules/40-define-functions/450-define-functions-short-syntax/es/README.md
@@ -33,6 +33,4 @@ Versión simplificada
 const sum = (a, b) => a + b;
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-short-syntax
-
 Ten en cuenta la ausencia de las llaves. Los desarrolladores que no están acostumbrados a este tipo de sintaxis a veces escriben código como `const sum = (a, b) => { a + b };` y luego se preguntan por qué no funciona. La respuesta es simple: si hay llaves, entonces no se está usando la forma simplificada y tendrás que agregar la palabra `return` para que la función devuelva un valor.
diff --git a/modules/40-define-functions/450-define-functions-short-syntax/ru/README.md b/modules/40-define-functions/450-define-functions-short-syntax/ru/README.md
index 5f7ef79d..62480f36 100644
--- a/modules/40-define-functions/450-define-functions-short-syntax/ru/README.md
+++ b/modules/40-define-functions/450-define-functions-short-syntax/ru/README.md
@@ -33,6 +33,4 @@ const sum = (a, b) => {
 const sum = (a, b) => a + b;
 ```
 
-https://replit.com/@hexlet/js-basics-define-functions-short-syntax
-
 Обратите внимание на отсутствие фигурных скобок. Разработчики, которые не привыкли использовать такой синтаксис, иногда пишут подобный код `const sum = (a, b) => { a + b };`, а потом долго не могут понять, почему он не работает. Ответ очень простой: если стоят фигурные скобки, то это не сокращенная форма, а значит, чтобы функция вернула значение, придётся поставить `return`.
diff --git a/modules/45-logic/10-bool-type/description.es.yml b/modules/45-logic/10-bool-type/description.es.yml
index 643b241f..ff7ceebc 100644
--- a/modules/45-logic/10-bool-type/description.es.yml
+++ b/modules/45-logic/10-bool-type/description.es.yml
@@ -50,7 +50,6 @@ theory: |
 
   
false

 
-  https://replit.com/@hexlet/js-basics-logic-bool-type
 
   Ahora probemos con un niño de seis meses:
 
diff --git a/modules/45-logic/10-bool-type/es/README.md b/modules/45-logic/10-bool-type/es/README.md
index ea5b24d0..3a1dbc07 100644
--- a/modules/45-logic/10-bool-type/es/README.md
+++ b/modules/45-logic/10-bool-type/es/README.md
@@ -46,8 +46,6 @@ console.log(isInfant(3));
 
 
false

 
-https://replit.com/@hexlet/js-basics-logic-bool-type
-
 Ahora probemos con un niño de seis meses:
 
 ```javascript
diff --git a/modules/45-logic/10-bool-type/ru/README.md b/modules/45-logic/10-bool-type/ru/README.md
index 6d639bc3..c3237f60 100644
--- a/modules/45-logic/10-bool-type/ru/README.md
+++ b/modules/45-logic/10-bool-type/ru/README.md
@@ -46,8 +46,6 @@ console.log(isInfant(3));
 
 
false

 
-https://replit.com/@hexlet/js-basics-logic-bool-type
-
 А теперь проверим ребенка, которому полгода:
 
 ```javascript
diff --git a/modules/45-logic/15-predicates/description.es.yml b/modules/45-logic/15-predicates/description.es.yml
index 0340367b..9dbeb4ff 100644
--- a/modules/45-logic/15-predicates/description.es.yml
+++ b/modules/45-logic/15-predicates/description.es.yml
@@ -11,7 +11,6 @@ theory: |
   ```
   
false

 
-  https://replit.com/@hexlet/js-basics-logic-bool-type
 
   Estas funciones se llaman funciones booleanas. Los boolenos (o funciones de pregunta) responden a una pregunta y siempre (¡sin excepciones!) devuelven `true` o `false`.
 
diff --git a/modules/45-logic/15-predicates/es/README.md b/modules/45-logic/15-predicates/es/README.md
index 07c1215d..a6640a81 100644
--- a/modules/45-logic/15-predicates/es/README.md
+++ b/modules/45-logic/15-predicates/es/README.md
@@ -7,8 +7,6 @@ console.log(isInfant(3));
 ```
 
false

 
-https://replit.com/@hexlet/js-basics-logic-bool-type
-
 Estas funciones se llaman funciones booleanas. Los boolenos (o funciones de pregunta) responden a una pregunta y siempre (¡sin excepciones!) devuelven `true` o `false`.
 
 En todos los lenguajes, los predicados se nombran de manera especial para facilitar el análisis. En JavaScript, los predicados generalmente comienzan con los prefijos `is`, `has` o `can`, pero no se limitan a estas palabras. Ejemplos:
diff --git a/modules/45-logic/15-predicates/ru/README.md b/modules/45-logic/15-predicates/ru/README.md
index 2de8be51..8f9f6428 100644
--- a/modules/45-logic/15-predicates/ru/README.md
+++ b/modules/45-logic/15-predicates/ru/README.md
@@ -7,8 +7,6 @@ console.log(isInfant(3));
 ```
 
false

 
-https://replit.com/@hexlet/js-basics-logic-bool-type
-
 Подобные функции называют предикатами. Функции-предикаты (или функции-вопросы) отвечают на какой-то вопрос и всегда (без исключений!) возвращают либо `true`, либо `false`.
 
 Предикаты во всех языках принято именовать особым образом для простоты анализа. В JavaScript предикаты, как правило, начинаются с префикса `is`, `has` или `can`, но не ограничены этими словами. Примеры:
diff --git a/modules/45-logic/20-logic-combine-expressions/description.es.yml b/modules/45-logic/20-logic-combine-expressions/description.es.yml
index b5ad0e56..b7a940e2 100644
--- a/modules/45-logic/20-logic-combine-expressions/description.es.yml
+++ b/modules/45-logic/20-logic-combine-expressions/description.es.yml
@@ -68,7 +68,6 @@ theory: |
   isFirstLetterInUpperCase('Robb');    // true
   ```
 
-  https://replit.com/@hexlet/js-basics-logica-operations
 
 instructions: |
 
diff --git a/modules/45-logic/20-logic-combine-expressions/en/README.md b/modules/45-logic/20-logic-combine-expressions/en/README.md
index 50b57863..9ab9514a 100644
--- a/modules/45-logic/20-logic-combine-expressions/en/README.md
+++ b/modules/45-logic/20-logic-combine-expressions/en/README.md
@@ -63,5 +63,3 @@ const isFirstLetterInUpperCase = (string) => {
 isFirstLetterInUpperCase('marmont'); // false
 isFirstLetterInUpperCase('Robb');    // true
 ```
-
-https://replit.com/@hexlet/js-basics-logica-operations
diff --git a/modules/45-logic/20-logic-combine-expressions/es/README.md b/modules/45-logic/20-logic-combine-expressions/es/README.md
index 951cedc6..6c574857 100644
--- a/modules/45-logic/20-logic-combine-expressions/es/README.md
+++ b/modules/45-logic/20-logic-combine-expressions/es/README.md
@@ -63,5 +63,3 @@ const isFirstLetterInUpperCase = (string) => {
 isFirstLetterInUpperCase('marmont'); // false
 isFirstLetterInUpperCase('Robb');    // true
 ```
-
-https://replit.com/@hexlet/js-basics-logica-operations
diff --git a/modules/45-logic/20-logic-combine-expressions/ru/README.md b/modules/45-logic/20-logic-combine-expressions/ru/README.md
index 54c86466..17eba8e3 100644
--- a/modules/45-logic/20-logic-combine-expressions/ru/README.md
+++ b/modules/45-logic/20-logic-combine-expressions/ru/README.md
@@ -63,5 +63,3 @@ const isFirstLetterInUpperCase = (string) => {
 isFirstLetterInUpperCase('marmont'); // false
 isFirstLetterInUpperCase('Robb');    // true
 ```
-
-https://replit.com/@hexlet/js-basics-logica-operations
diff --git a/modules/45-logic/25-logical-operators/description.es.yml b/modules/45-logic/25-logical-operators/description.es.yml
index 79888447..5cc984d1 100644
--- a/modules/45-logic/25-logical-operators/description.es.yml
+++ b/modules/45-logic/25-logical-operators/description.es.yml
@@ -60,7 +60,6 @@ theory: |
   isGoodApartment(80, 'Main Street');    // true
   ```
 
-  https://replit.com/@hexlet/js-basics-logical-operators
 
   El área de las matemáticas que estudia los operadores lógicos se llama álgebra booleana. A continuación se muestran las "tablas de verdad" que permiten determinar el resultado de la aplicación de un operador:
 
diff --git a/modules/45-logic/25-logical-operators/es/README.md b/modules/45-logic/25-logical-operators/es/README.md
index 5eaec9f9..d7d9999d 100644
--- a/modules/45-logic/25-logical-operators/es/README.md
+++ b/modules/45-logic/25-logical-operators/es/README.md
@@ -56,8 +56,6 @@ isGoodApartment(120, 'Main Street');   // true
 isGoodApartment(80, 'Main Street');    // true
 ```
 
-https://replit.com/@hexlet/js-basics-logical-operators
-
 El área de las matemáticas que estudia los operadores lógicos se llama álgebra booleana. A continuación se muestran las "tablas de verdad" que permiten determinar el resultado de la aplicación de un operador:
 
 ## Y `&&`
diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md
index 7c9735b4..80adc4b3 100644
--- a/modules/45-logic/25-logical-operators/ru/README.md
+++ b/modules/45-logic/25-logical-operators/ru/README.md
@@ -56,8 +56,6 @@ isGoodApartment(120, 'Main Street');   // true
 isGoodApartment(80, 'Main Street');    // true
 ```
 
-https://replit.com/@hexlet/js-basics-logical-operators
-
 Область математики, в которой изучаются логические операторы, называется булевой алгеброй. Ниже показаны «таблицы истинности» — по ним можно определить, каким будет результат применения оператора:
 
 ## И `&&`
diff --git a/modules/45-logic/28-logical-negation/description.es.yml b/modules/45-logic/28-logical-negation/description.es.yml
index 7d161892..3eed1231 100644
--- a/modules/45-logic/28-logical-negation/description.es.yml
+++ b/modules/45-logic/28-logical-negation/description.es.yml
@@ -14,7 +14,6 @@ theory: |
   !isEven(10); // false
   ```
 
-  https://replit.com/@hexlet/js-basics-logical-negation
 
   Es decir, simplemente agregamos `!` antes de llamar a la función y obtenemos la acción opuesta.
 
diff --git a/modules/45-logic/28-logical-negation/es/README.md b/modules/45-logic/28-logical-negation/es/README.md
index 69674909..da989857 100644
--- a/modules/45-logic/28-logical-negation/es/README.md
+++ b/modules/45-logic/28-logical-negation/es/README.md
@@ -10,8 +10,6 @@ isEven(10);  // true
 !isEven(10); // false
 ```
 
-https://replit.com/@hexlet/js-basics-logical-negation
-
 Es decir, simplemente agregamos `!` antes de llamar a la función y obtenemos la acción opuesta.
 
 La negación es una herramienta poderosa que permite expresar reglas previstas de manera concisa en el código sin necesidad de escribir nuevas funciones.
diff --git a/modules/45-logic/28-logical-negation/ru/README.md b/modules/45-logic/28-logical-negation/ru/README.md
index 69dc65fa..5b9dc262 100644
--- a/modules/45-logic/28-logical-negation/ru/README.md
+++ b/modules/45-logic/28-logical-negation/ru/README.md
@@ -10,8 +10,6 @@ isEven(10);  // true
 !isEven(10); // false
 ```
 
-https://replit.com/@hexlet/js-basics-logical-negation
-
 То есть мы просто добавили `!` слева от вызова функции и получили обратное действие.
 
 Отрицание — мощный инструмент, который позволяет лаконично выражать задуманные правила в коде без необходимости писать новые функции.
diff --git a/modules/45-logic/70-logical-expressions/description.es.yml b/modules/45-logic/70-logical-expressions/description.es.yml
index 35eeee14..519e956e 100644
--- a/modules/45-logic/70-logical-expressions/description.es.yml
+++ b/modules/45-logic/70-logical-expressions/description.es.yml
@@ -44,7 +44,6 @@ theory: |
   undefined || ''; // ''
   ```
 
-  https://replit.com/@hexlet/js-basics-logical-expressions
 
   Si `name` toma uno de los valores falsy, la constante `value` se le asignará una cadena vacía. En este caso, en el código posterior, podemos trabajar con `value` como si fuera una cadena.
 
diff --git a/modules/45-logic/70-logical-expressions/es/README.md b/modules/45-logic/70-logical-expressions/es/README.md
index ae509802..92bd2e71 100644
--- a/modules/45-logic/70-logical-expressions/es/README.md
+++ b/modules/45-logic/70-logical-expressions/es/README.md
@@ -40,8 +40,6 @@ const value = name || '';
 undefined || ''; // ''
 ```
 
-https://replit.com/@hexlet/js-basics-logical-expressions
-
 Si `name` toma uno de los valores falsy, la constante `value` se le asignará una cadena vacía. En este caso, en el código posterior, podemos trabajar con `value` como si fuera una cadena.
 
 Pero aquí hay un posible error. Si `name` contiene un valor falsy y la asignación de valores a la constante `value` como `0`, `undefined`, `NaN` o `null` es aceptable, entonces el código anterior dejará de funcionar correctamente:
diff --git a/modules/45-logic/70-logical-expressions/ru/README.md b/modules/45-logic/70-logical-expressions/ru/README.md
index d0f927a1..045de945 100644
--- a/modules/45-logic/70-logical-expressions/ru/README.md
+++ b/modules/45-logic/70-logical-expressions/ru/README.md
@@ -40,8 +40,6 @@ const value = name || '';
 undefined || ''; // ''
 ```
 
-https://replit.com/@hexlet/js-basics-logical-expressions
-
 Если `name` примет одно из falsy-значений, константе `value` будет присвоена пустая строка. В этом случае в последующем коде мы сможем работать с `value` как со строкой.
 
 Но здесь есть потенциальный баг. Если `name` содержит falsy-значение, а присваивание константе value значений типа `0`, `undefined`, `NaN` или `null` допустимо, то код выше начнет работать неверно:
diff --git a/modules/48-conditionals/30-if/description.es.yml b/modules/48-conditionals/30-if/description.es.yml
index 72b74518..e5bbab64 100644
--- a/modules/48-conditionals/30-if/description.es.yml
+++ b/modules/48-conditionals/30-if/description.es.yml
@@ -21,7 +21,6 @@ theory: |
   getTypeOfSentence('Hodor?'); // question
   ```
 
-  https://replit.com/@hexlet/js-basics-if
 
   `if` es una estructura del lenguaje que controla el orden de ejecución de las instrucciones. Entre paréntesis se le pasa una expresión booleana, y luego se describe un bloque de código entre llaves. Este bloque de código se ejecutará solo si el predicado es verdadero.
 
diff --git a/modules/48-conditionals/30-if/es/README.md b/modules/48-conditionals/30-if/es/README.md
index f5ddfb23..64416164 100644
--- a/modules/48-conditionals/30-if/es/README.md
+++ b/modules/48-conditionals/30-if/es/README.md
@@ -17,8 +17,6 @@ getTypeOfSentence('Hodor');  // general
 getTypeOfSentence('Hodor?'); // question
 ```
 
-https://replit.com/@hexlet/js-basics-if
-
 `if` es una estructura del lenguaje que controla el orden de ejecución de las instrucciones. Entre paréntesis se le pasa una expresión booleana, y luego se describe un bloque de código entre llaves. Este bloque de código se ejecutará solo si el predicado es verdadero.
 
 Si el predicado es falso, se omitirá el bloque de código entre llaves y la función continuará su ejecución. En nuestro caso, la siguiente línea de código, `return 'general';`, hará que la función devuelva una cadena y termine.
diff --git a/modules/48-conditionals/30-if/ru/README.md b/modules/48-conditionals/30-if/ru/README.md
index f2b6ea9d..1da986ed 100644
--- a/modules/48-conditionals/30-if/ru/README.md
+++ b/modules/48-conditionals/30-if/ru/README.md
@@ -17,8 +17,6 @@ getTypeOfSentence('Hodor');  // general
 getTypeOfSentence('Hodor?'); // question
 ```
 
-https://replit.com/@hexlet/js-basics-if
-
 `if` - конструкция языка, управляющая порядком выполнения инструкций. В скобках ей передается выражение-предикат, а затем описывается блок кода в фигурных скобках. Этот блок кода будет выполнен, только если предикат — истина.
 
 Если предикат — ложь, то блок кода в фигурных скобках пропускается, и функция продолжает свое выполнение дальше. В нашем случае следующая строчка кода — `return 'general';` — заставит функцию вернуть строку и завершиться.
diff --git a/modules/48-conditionals/40-if-else/description.es.yml b/modules/48-conditionals/40-if-else/description.es.yml
index 56e15bc0..1706c333 100644
--- a/modules/48-conditionals/40-if-else/description.es.yml
+++ b/modules/48-conditionals/40-if-else/description.es.yml
@@ -34,7 +34,6 @@ theory: |
   };
   ```
 
-  https://replit.com/@hexlet/js-basics-if-else
 
   Hemos agregado la palabra clave `else` y un nuevo bloque con llaves. Este bloque se ejecutará solo si la condición en `if` es falsa.
 
diff --git a/modules/48-conditionals/40-if-else/es/README.md b/modules/48-conditionals/40-if-else/es/README.md
index b039055d..b1f7c12e 100644
--- a/modules/48-conditionals/40-if-else/es/README.md
+++ b/modules/48-conditionals/40-if-else/es/README.md
@@ -30,8 +30,6 @@ const getTypeOfSentence = (sentence) => {
 };
 ```
 
-https://replit.com/@hexlet/js-basics-if-else
-
 Hemos agregado la palabra clave `else` y un nuevo bloque con llaves. Este bloque se ejecutará solo si la condición en `if` es falsa.
 
 Hay dos formas de estructurar la construcción *if-else*. Usando la negación, se puede cambiar el orden de los bloques:
diff --git a/modules/48-conditionals/40-if-else/ru/README.md b/modules/48-conditionals/40-if-else/ru/README.md
index effa5f80..974d2729 100644
--- a/modules/48-conditionals/40-if-else/ru/README.md
+++ b/modules/48-conditionals/40-if-else/ru/README.md
@@ -30,8 +30,6 @@ const getTypeOfSentence = (sentence) => {
 };
 ```
 
-https://replit.com/@hexlet/js-basics-if-else
-
 Мы добавили ключевое слово `else` и новый блок с фигурными скобками. Этот блок выполнится, только если условие в `if` — ложь.
 
 Существует два способа оформления конструкции *if-else*. С помощью отрицания можно изменить порядок блоков:
diff --git a/modules/48-conditionals/50-else-if/description.es.yml b/modules/48-conditionals/50-else-if/description.es.yml
index 94a47ef3..2f5c922d 100644
--- a/modules/48-conditionals/50-else-if/description.es.yml
+++ b/modules/48-conditionals/50-else-if/description.es.yml
@@ -28,7 +28,6 @@ theory: |
   getTypeOfSentence('No!');  // Sentence is exclamation
   ```
 
-  https://replit.com/@hexlet/js-basics-conditionals
 
   Hemos agregado otra verificación ("exclamation" se traduce como «exclamación»). Técnicamente, la función funciona, pero hay problemas desde el punto de vista semántico.
 
diff --git a/modules/48-conditionals/50-else-if/en/README.md b/modules/48-conditionals/50-else-if/en/README.md
index 635b947c..ebbae063 100644
--- a/modules/48-conditionals/50-else-if/en/README.md
+++ b/modules/48-conditionals/50-else-if/en/README.md
@@ -24,8 +24,6 @@ getTypeOfSentence('No');   // 'Sentence is normal'
 getTypeOfSentence('No!');  // 'Sentence is exclamation'
 ```
 
-https://replit.com/@hexlet/js-basics-conditionals
-
 We added one more test. Technically the function works, but there are semantics issues.
 
 - It tests for the question mark in any case, regardless of whether an exclamation point was found or not
diff --git a/modules/48-conditionals/50-else-if/es/README.md b/modules/48-conditionals/50-else-if/es/README.md
index 58285f78..05dda50a 100644
--- a/modules/48-conditionals/50-else-if/es/README.md
+++ b/modules/48-conditionals/50-else-if/es/README.md
@@ -24,8 +24,6 @@ getTypeOfSentence('No');   // Sentence is normal
 getTypeOfSentence('No!');  // Sentence is exclamation
 ```
 
-https://replit.com/@hexlet/js-basics-conditionals
-
 Hemos agregado otra verificación ("exclamation" se traduce como «exclamación»). Técnicamente, la función funciona, pero hay problemas desde el punto de vista semántico.
 
 - La verificación de la presencia del signo de interrogación ocurre de todos modos, incluso si ya se ha detectado el signo de exclamación.
diff --git a/modules/48-conditionals/50-else-if/ru/README.md b/modules/48-conditionals/50-else-if/ru/README.md
index 093ce65f..5b07c51e 100644
--- a/modules/48-conditionals/50-else-if/ru/README.md
+++ b/modules/48-conditionals/50-else-if/ru/README.md
@@ -24,8 +24,6 @@ getTypeOfSentence('No');   // Sentence is normal
 getTypeOfSentence('No!');  // Sentence is exclamation
 ```
 
-https://replit.com/@hexlet/js-basics-conditionals
-
 Мы добавили ещё одну проверку ("exclamation" переводится «восклицание»). Технически функция работает, но с точки зрения семантики есть проблемы.
 
 - Проверка на наличие вопросительного знака происходит в любом случае, даже если уже был обнаружен восклицательный знак.
diff --git a/modules/48-conditionals/60-ternary-operator/description.es.yml b/modules/48-conditionals/60-ternary-operator/description.es.yml
index ad18c87e..029ac317 100644
--- a/modules/48-conditionals/60-ternary-operator/description.es.yml
+++ b/modules/48-conditionals/60-ternary-operator/description.es.yml
@@ -69,7 +69,6 @@ theory: |
   getTypeOfSentence('Hodor?'); // question
   ```
 
-  https://replit.com/@hexlet/js-basics-ternary-operator
 
   ---
 
diff --git a/modules/48-conditionals/60-ternary-operator/es/README.md b/modules/48-conditionals/60-ternary-operator/es/README.md
index 3900bf3f..9b653ba6 100644
--- a/modules/48-conditionals/60-ternary-operator/es/README.md
+++ b/modules/48-conditionals/60-ternary-operator/es/README.md
@@ -65,8 +65,6 @@ getTypeOfSentence('Hodor');  // normal
 getTypeOfSentence('Hodor?'); // question
 ```
 
-https://replit.com/@hexlet/js-basics-ternary-operator
-
 ---
 
 Si recuerdas el poder de las expresiones, probablemente ya te hayas dado cuenta de que se puede anidar un operador ternario dentro de otro. **No hagas esto :)**. Este tipo de código es difícil de leer y depurar, y es una mala práctica.
diff --git a/modules/48-conditionals/60-ternary-operator/ru/README.md b/modules/48-conditionals/60-ternary-operator/ru/README.md
index b9e518a6..e7b17cbf 100644
--- a/modules/48-conditionals/60-ternary-operator/ru/README.md
+++ b/modules/48-conditionals/60-ternary-operator/ru/README.md
@@ -65,8 +65,6 @@ getTypeOfSentence('Hodor');  // normal
 getTypeOfSentence('Hodor?'); // question
 ```
 
-https://replit.com/@hexlet/js-basics-ternary-operator
-
 ---
 
 Если вы помните, в чём сила выражений, то вероятно уже догадались, что тернарный оператор можно вкладывать в тернарный оператор. **Не делайте этого :)** Такой код тяжело и читать, и отлаживать, это очень плохая практика.
diff --git a/modules/48-conditionals/65-switch/description.es.yml b/modules/48-conditionals/65-switch/description.es.yml
index 38a147d6..49cb7f63 100644
--- a/modules/48-conditionals/65-switch/description.es.yml
+++ b/modules/48-conditionals/65-switch/description.es.yml
@@ -97,7 +97,6 @@ theory: |
   };
   ```
 
-  https://replit.com/@hexlet/js-basics-switch
 
   Aunque el switch se encuentra en el código, técnicamente siempre se puede prescindir de él. El beneficio clave de su uso es que expresa mejor la intención del programador cuando se necesitan comprobar valores específicos de una variable. Aunque el código físicamente se vuelve un poco más largo, es más fácil de leer en comparación con los bloques *else if*.
 
diff --git a/modules/48-conditionals/65-switch/es/README.md b/modules/48-conditionals/65-switch/es/README.md
index fe56a95f..1cfb1238 100644
--- a/modules/48-conditionals/65-switch/es/README.md
+++ b/modules/48-conditionals/65-switch/es/README.md
@@ -93,6 +93,4 @@ La segunda forma es más simple y corta. En lugar de crear una variable, el `cas
 };
 ```
 
-https://replit.com/@hexlet/js-basics-switch
-
 Aunque el switch se encuentra en el código, técnicamente siempre se puede prescindir de él. El beneficio clave de su uso es que expresa mejor la intención del programador cuando se necesitan comprobar valores específicos de una variable. Aunque el código físicamente se vuelve un poco más largo, es más fácil de leer en comparación con los bloques *else if*.
diff --git a/modules/48-conditionals/65-switch/ru/README.md b/modules/48-conditionals/65-switch/ru/README.md
index ea3390cb..e06f5e40 100644
--- a/modules/48-conditionals/65-switch/ru/README.md
+++ b/modules/48-conditionals/65-switch/ru/README.md
@@ -93,6 +93,4 @@ switch (count) {
 };
 ```
 
-https://replit.com/@hexlet/js-basics-switch
-
 Switch хоть и встречается в коде, но технически всегда можно обойтись без него. Ключевая польза при его использовании в том, что он лучше выражает намерение программиста, когда нужно проверять конкретные значения переменной. Хотя кода и стало физически чуть больше, читать его легче, в отличие от блоков *else if*.
diff --git a/modules/50-loops/10-while/description.es.yml b/modules/50-loops/10-while/description.es.yml
index 6240a1c4..4c1b1fed 100644
--- a/modules/50-loops/10-while/description.es.yml
+++ b/modules/50-loops/10-while/description.es.yml
@@ -43,7 +43,6 @@ theory: |
   finished!
- https://replit.com/@hexlet/js-basics-while En el código de la función, se utiliza un bucle `while`. Este bucle consta de tres elementos: diff --git a/modules/50-loops/10-while/en/README.md b/modules/50-loops/10-while/en/README.md index c0bc1d43..0ec7d681 100644 --- a/modules/50-loops/10-while/en/README.md +++ b/modules/50-loops/10-while/en/README.md @@ -40,8 +40,6 @@ printNumbers(3); finished! -https://replit.com/@hexlet/js-basics-while - Here we use a `while` loop. It has three elements: * The keyword here is `while`. It is not a function call, although it resembles it diff --git a/modules/50-loops/10-while/es/README.md b/modules/50-loops/10-while/es/README.md index ab614848..64cfb365 100644 --- a/modules/50-loops/10-while/es/README.md +++ b/modules/50-loops/10-while/es/README.md @@ -39,8 +39,6 @@ printNumbers(3); finished! -https://replit.com/@hexlet/js-basics-while - En el código de la función, se utiliza un bucle `while`. Este bucle consta de tres elementos: * La palabra clave `while`. Aunque se parece a una llamada de función, no es lo mismo. diff --git a/modules/50-loops/10-while/ru/README.md b/modules/50-loops/10-while/ru/README.md index 3b3467a4..cfea108d 100644 --- a/modules/50-loops/10-while/ru/README.md +++ b/modules/50-loops/10-while/ru/README.md @@ -40,8 +40,6 @@ printNumbers(3); finished! -https://replit.com/@hexlet/js-basics-while - В коде функции использован цикл `while`. Он состоит из трёх элементов: * Ключевое слово `while`. Несмотря на схожесть с вызовом функций, это не вызов функции. diff --git a/modules/50-loops/20-aggregation-numbers/description.es.yml b/modules/50-loops/20-aggregation-numbers/description.es.yml index 2fb1559d..19248026 100644 --- a/modules/50-loops/20-aggregation-numbers/description.es.yml +++ b/modules/50-loops/20-aggregation-numbers/description.es.yml @@ -45,7 +45,6 @@ theory: | }; ``` - https://replit.com/@hexlet/js-basics-aggregation-numbers La estructura general del bucle aquí es estándar. Hay un contador que se inicializa con el valor inicial del rango, luego viene el bucle con la condición de detenerse cuando se alcanza el final del rango, y finalmente, se cambia el contador al final del cuerpo del bucle. El número de iteraciones en este bucle es igual a `finish - start + 1`. Es decir, para un rango de 5 a 7, esto es 7 - 5 + 1, es decir, 3 iteraciones. diff --git a/modules/50-loops/20-aggregation-numbers/es/README.md b/modules/50-loops/20-aggregation-numbers/es/README.md index a95916f0..0e01808e 100644 --- a/modules/50-loops/20-aggregation-numbers/es/README.md +++ b/modules/50-loops/20-aggregation-numbers/es/README.md @@ -41,8 +41,6 @@ const sumNumbersFromRange = (start, finish) => { }; ``` -https://replit.com/@hexlet/js-basics-aggregation-numbers - La estructura general del bucle aquí es estándar. Hay un contador que se inicializa con el valor inicial del rango, luego viene el bucle con la condición de detenerse cuando se alcanza el final del rango, y finalmente, se cambia el contador al final del cuerpo del bucle. El número de iteraciones en este bucle es igual a `finish - start + 1`. Es decir, para un rango de 5 a 7, esto es 7 - 5 + 1, es decir, 3 iteraciones. Las principales diferencias con el procesamiento normal están relacionadas con la lógica de cálculo del resultado. En los problemas de agregación, siempre hay una variable que almacena el resultado del bucle. En el código anterior, esta variable es `sum`. En cada iteración del bucle, se actualiza sumando el siguiente número en el rango: `sum = sum + i`. Todo el proceso se ve así: diff --git a/modules/50-loops/20-aggregation-numbers/ru/README.md b/modules/50-loops/20-aggregation-numbers/ru/README.md index d8f41aca..40cb1ac9 100644 --- a/modules/50-loops/20-aggregation-numbers/ru/README.md +++ b/modules/50-loops/20-aggregation-numbers/ru/README.md @@ -41,8 +41,6 @@ const sumNumbersFromRange = (start, finish) => { }; ``` -https://replit.com/@hexlet/js-basics-aggregation-numbers - Общая структура цикла здесь стандартна. Есть счетчик, который инициализируется начальным значением диапазона, есть сам цикл с условием остановки при достижении конца диапазона, и, наконец, изменение счетчика в конце тела цикла. Количество итераций в таком цикле равно `finish - start + 1`. То есть для диапазона от 5 до 7 – это 7 - 5 + 1, то есть 3 итерации. Главные отличия от обычной обработки связаны с логикой вычислений результата. В задачах на агрегацию всегда есть какая-то переменная, которая хранит внутри себя результат работы цикла. В коде выше это `sum`. На каждой итерации цикла происходит её изменение, прибавление следующего числа в диапазоне: `sum = sum + i`. Весь процесс выглядит так: diff --git a/modules/50-loops/23-aggregation-strings/description.es.yml b/modules/50-loops/23-aggregation-strings/description.es.yml index 20e2d75e..4afe0bda 100644 --- a/modules/50-loops/23-aggregation-strings/description.es.yml +++ b/modules/50-loops/23-aggregation-strings/description.es.yml @@ -29,7 +29,6 @@ theory: | }; ``` - https://replit.com/@hexlet/js-basics-aggreagation Veamos cómo se ejecuta este código paso a paso: diff --git a/modules/50-loops/23-aggregation-strings/en/README.md b/modules/50-loops/23-aggregation-strings/en/README.md index 33ef9f69..181358dc 100644 --- a/modules/50-loops/23-aggregation-strings/en/README.md +++ b/modules/50-loops/23-aggregation-strings/en/README.md @@ -25,8 +25,6 @@ const repeat = (text, times) => { }; ``` -https://replit.com/@hexlet/js-basics-aggreagation - Break down the code's execution into steps: ```javascript diff --git a/modules/50-loops/23-aggregation-strings/es/README.md b/modules/50-loops/23-aggregation-strings/es/README.md index 9ea7b1bf..72d9ae2f 100644 --- a/modules/50-loops/23-aggregation-strings/es/README.md +++ b/modules/50-loops/23-aggregation-strings/es/README.md @@ -25,8 +25,6 @@ const repeat = (text, times) => { }; ``` -https://replit.com/@hexlet/js-basics-aggreagation - Veamos cómo se ejecuta este código paso a paso: ```javascript diff --git a/modules/50-loops/23-aggregation-strings/ru/README.md b/modules/50-loops/23-aggregation-strings/ru/README.md index eae01db5..052f8b6a 100644 --- a/modules/50-loops/23-aggregation-strings/ru/README.md +++ b/modules/50-loops/23-aggregation-strings/ru/README.md @@ -25,8 +25,6 @@ const repeat = (text, times) => { }; ``` -https://replit.com/@hexlet/js-basics-aggreagation - Распишем выполнение этого кода по шагам: ```javascript diff --git a/modules/50-loops/25-iteration-over-string/description.es.yml b/modules/50-loops/25-iteration-over-string/description.es.yml index 0e703220..c22997c1 100644 --- a/modules/50-loops/25-iteration-over-string/description.es.yml +++ b/modules/50-loops/25-iteration-over-string/description.es.yml @@ -25,7 +25,6 @@ theory: | // => a ``` - https://replit.com/@hexlet/js-basic-iteration-over-string Lo más importante en este código es establecer la condición correcta en el `while`. Esto se puede hacer de dos formas: `i < name.length` o `i <= name.length - 1`. Ambas formas conducen al mismo resultado. diff --git a/modules/50-loops/25-iteration-over-string/es/README.md b/modules/50-loops/25-iteration-over-string/es/README.md index a89f4b19..1f0547c1 100644 --- a/modules/50-loops/25-iteration-over-string/es/README.md +++ b/modules/50-loops/25-iteration-over-string/es/README.md @@ -21,6 +21,4 @@ printNameBySymbol(name); // => a ``` -https://replit.com/@hexlet/js-basic-iteration-over-string - Lo más importante en este código es establecer la condición correcta en el `while`. Esto se puede hacer de dos formas: `i < name.length` o `i <= name.length - 1`. Ambas formas conducen al mismo resultado. diff --git a/modules/50-loops/25-iteration-over-string/ru/README.md b/modules/50-loops/25-iteration-over-string/ru/README.md index 08e11cae..6218bf1f 100644 --- a/modules/50-loops/25-iteration-over-string/ru/README.md +++ b/modules/50-loops/25-iteration-over-string/ru/README.md @@ -21,6 +21,4 @@ printNameBySymbol(name); // => a ``` -https://replit.com/@hexlet/js-basic-iteration-over-string - Самое главное в этом коде, поставить правильное условие в `while`. Это можно сделать сразу двумя способами: `i < name.length` или `i <= name.length - 1`. Оба способа приводят к одному результату. diff --git a/modules/50-loops/26-conditions-inside-loops/description.es.yml b/modules/50-loops/26-conditions-inside-loops/description.es.yml index 1fcb1faa..7a52b6e4 100644 --- a/modules/50-loops/26-conditions-inside-loops/description.es.yml +++ b/modules/50-loops/26-conditions-inside-loops/description.es.yml @@ -35,7 +35,6 @@ theory: | }; ``` - https://replit.com/@hexlet/js-basics-condition-inside-loops Este problema es una operación de agregación. Aunque no cuenta todos los caracteres, aún es necesario analizar cada uno para calcular la suma total. diff --git a/modules/50-loops/26-conditions-inside-loops/es/README.md b/modules/50-loops/26-conditions-inside-loops/es/README.md index eae7be2f..a2535cd3 100644 --- a/modules/50-loops/26-conditions-inside-loops/es/README.md +++ b/modules/50-loops/26-conditions-inside-loops/es/README.md @@ -31,8 +31,6 @@ const countChars = (str, char) => { }; ``` -https://replit.com/@hexlet/js-basics-condition-inside-loops - Este problema es una operación de agregación. Aunque no cuenta todos los caracteres, aún es necesario analizar cada uno para calcular la suma total. La diferencia clave de este bucle con los que hemos visto anteriormente es que tiene una condición dentro del cuerpo. La variable `count` solo se incrementa cuando el carácter actual coincide con el esperado. diff --git a/modules/50-loops/26-conditions-inside-loops/ru/README.md b/modules/50-loops/26-conditions-inside-loops/ru/README.md index b7d3d3a5..985c3756 100644 --- a/modules/50-loops/26-conditions-inside-loops/ru/README.md +++ b/modules/50-loops/26-conditions-inside-loops/ru/README.md @@ -31,8 +31,6 @@ const countChars = (str, char) => { }; ``` -https://replit.com/@hexlet/js-basics-condition-inside-loops - Эта задача является агрегирующей. Несмотря на то, что она считает не все символы, для подсчета самой суммы все равно приходится анализировать каждый символ. Ключевое отличие этого цикла от рассмотренных в наличии условия внутри тела. Переменная `count` увеличивается только в том случае, когда текущий рассматриваемый символ совпадает с ожидаемым. diff --git a/modules/50-loops/28-build-strings/description.es.yml b/modules/50-loops/28-build-strings/description.es.yml index 9dbbc35f..e7d3c905 100644 --- a/modules/50-loops/28-build-strings/description.es.yml +++ b/modules/50-loops/28-build-strings/description.es.yml @@ -35,7 +35,6 @@ theory: | reverse(''); // '' ``` - https://replit.com/@hexlet/js-basics-iteration-over-strings El único aspecto posiblemente complicado de este código es comprender cómo se construye la cadena. Dado que cada carácter siguiente se adjunta a la cadena resultante desde la izquierda, al final la cadena queda invertida. diff --git a/modules/50-loops/28-build-strings/en/README.md b/modules/50-loops/28-build-strings/en/README.md index b9541418..4c169164 100644 --- a/modules/50-loops/28-build-strings/en/README.md +++ b/modules/50-loops/28-build-strings/en/README.md @@ -31,6 +31,4 @@ reverse(name); // 'narB' reverse(''); // '' ``` -https://replit.com/@hexlet/js-basics-iteration-over-strings - Perhaps the only tricky part here is getting a feel of how the string itself is built. Since each next character is attached to the resulting string on the left, the string ends up reversed. diff --git a/modules/50-loops/28-build-strings/es/README.md b/modules/50-loops/28-build-strings/es/README.md index 7daec7b4..b15c96b8 100644 --- a/modules/50-loops/28-build-strings/es/README.md +++ b/modules/50-loops/28-build-strings/es/README.md @@ -31,6 +31,4 @@ reverse(name); // 'narB' reverse(''); // '' ``` -https://replit.com/@hexlet/js-basics-iteration-over-strings - El único aspecto posiblemente complicado de este código es comprender cómo se construye la cadena. Dado que cada carácter siguiente se adjunta a la cadena resultante desde la izquierda, al final la cadena queda invertida. diff --git a/modules/50-loops/28-build-strings/ru/README.md b/modules/50-loops/28-build-strings/ru/README.md index fcaa9f48..73345537 100644 --- a/modules/50-loops/28-build-strings/ru/README.md +++ b/modules/50-loops/28-build-strings/ru/README.md @@ -31,6 +31,4 @@ reverse(name); // 'narB' reverse(''); // '' ``` -https://replit.com/@hexlet/js-basics-iteration-over-strings - Единственный возможно сложный момент в этом коде – прочувствовать, как собирается сама строка. Так как каждый следующий символ прикрепляется к результирующей строке слева, то, в конечном итоге, строка оказывается перевернута. diff --git a/modules/50-loops/50-mutators/description.es.yml b/modules/50-loops/50-mutators/description.es.yml index 90781b11..bd0419b4 100644 --- a/modules/50-loops/50-mutators/description.es.yml +++ b/modules/50-loops/50-mutators/description.es.yml @@ -45,7 +45,6 @@ theory: | console.log(x); // => 7 ``` - https://replit.com/@hexlet/js-basic-mutators ¿Qué está sucediendo aquí? diff --git a/modules/50-loops/50-mutators/es/README.md b/modules/50-loops/50-mutators/es/README.md index 960a1dab..378bd377 100644 --- a/modules/50-loops/50-mutators/es/README.md +++ b/modules/50-loops/50-mutators/es/README.md @@ -41,8 +41,6 @@ console.log(x++); // => 6 console.log(x); // => 7 ``` -https://replit.com/@hexlet/js-basic-mutators - ¿Qué está sucediendo aquí? 1. Imprimimos en la pantalla `++x`. Esto es un incremento prefijo, por lo que primero se incrementa el valor de la variable en 1, luego se devuelve el resultado y se imprime en la pantalla. diff --git a/modules/50-loops/50-mutators/ru/README.md b/modules/50-loops/50-mutators/ru/README.md index 52400f6f..2b757390 100644 --- a/modules/50-loops/50-mutators/ru/README.md +++ b/modules/50-loops/50-mutators/ru/README.md @@ -41,8 +41,6 @@ console.log(x++); // => 6 console.log(x); // => 7 ``` -https://replit.com/@hexlet/js-basic-mutators - Что происходит? 1. Вывели на экран `++x`. Это префиксный инкремент, поэтому сначала значение переменной увеличилось на 1, потом результат вернулся и вывелся на экран. diff --git a/modules/50-loops/55-return-from-loops/description.es.yml b/modules/50-loops/55-return-from-loops/description.es.yml index a143cef2..6ad3ea13 100644 --- a/modules/50-loops/55-return-from-loops/description.es.yml +++ b/modules/50-loops/55-return-from-loops/description.es.yml @@ -37,7 +37,6 @@ theory: | isPrime(4); // false ``` - https://replit.com/@hexlet/js-basics-conditions-inside-loops El algoritmo está diseñado de tal manera que, si encontramos al menos un divisor en el rango de la división secuencial entre números de 2 a `x / 2`, entonces el número pasado como argumento no es primo, y no tiene sentido continuar las comprobaciones. En este punto, deberíamos devolver `false`. diff --git a/modules/50-loops/55-return-from-loops/en/README.md b/modules/50-loops/55-return-from-loops/en/README.md index a42966e4..54c5c2cb 100644 --- a/modules/50-loops/55-return-from-loops/en/README.md +++ b/modules/50-loops/55-return-from-loops/en/README.md @@ -33,8 +33,6 @@ isPrime(3); // true isPrime(4); // false ``` -https://replit.com/@hexlet/js-basics-conditions-inside-loops - The algorithm is built like so: if during the successive division by numbers up to `x / 2`, there is at least one result without a remainder, then the given argument is not a prime number, and therefore further computations are pointless. At this point, it returns `false`. And only if the entire loop is completed can we say that the number is prime since no number by which it can be divided without a remainder can be found. diff --git a/modules/50-loops/55-return-from-loops/es/README.md b/modules/50-loops/55-return-from-loops/es/README.md index 236ca7e5..8136cf90 100644 --- a/modules/50-loops/55-return-from-loops/es/README.md +++ b/modules/50-loops/55-return-from-loops/es/README.md @@ -33,8 +33,6 @@ isPrime(3); // true isPrime(4); // false ``` -https://replit.com/@hexlet/js-basics-conditions-inside-loops - El algoritmo está diseñado de tal manera que, si encontramos al menos un divisor en el rango de la división secuencial entre números de 2 a `x / 2`, entonces el número pasado como argumento no es primo, y no tiene sentido continuar las comprobaciones. En este punto, deberíamos devolver `false`. Solamente si el bucle se ejecuta por completo, podemos concluir que el número es primo, ya que no se encontró ningún número que sea divisor sin residuo. diff --git a/modules/50-loops/55-return-from-loops/ru/README.md b/modules/50-loops/55-return-from-loops/ru/README.md index 18a3c52e..1e72c81f 100644 --- a/modules/50-loops/55-return-from-loops/ru/README.md +++ b/modules/50-loops/55-return-from-loops/ru/README.md @@ -33,8 +33,6 @@ isPrime(3); // true isPrime(4); // false ``` -https://replit.com/@hexlet/js-basics-conditions-inside-loops - Алгоритм построен таким образом, что если во время последовательного деления на числа до `x / 2` находится хоть одно, которое делит без остатка, то переданный аргумент — не простое число, а значит дальнейшие вычисления не имеют смысла. В этом месте стоит возврат `false`. И только если цикл отработал целиком, можно сделать вывод, что число — простое, так как не было найдено ни одного числа, которое делит число без остатка. diff --git a/modules/50-loops/70-for/description.es.yml b/modules/50-loops/70-for/description.es.yml index ddc1f756..2e5b4967 100644 --- a/modules/50-loops/70-for/description.es.yml +++ b/modules/50-loops/70-for/description.es.yml @@ -18,7 +18,6 @@ theory: | }; ``` - https://replit.com/@hexlet/js-basics-for Se puede leer de la siguiente manera: *el bucle con el índice `i` se repite mientras `i < str.length`. Después de cada paso incrementa `i` en 1*. diff --git a/modules/50-loops/70-for/es/README.md b/modules/50-loops/70-for/es/README.md index 13421ff9..d09b7d88 100644 --- a/modules/50-loops/70-for/es/README.md +++ b/modules/50-loops/70-for/es/README.md @@ -14,8 +14,6 @@ const reverseString = (str) => { }; ``` -https://replit.com/@hexlet/js-basics-for - Se puede leer de la siguiente manera: *el bucle con el índice `i` se repite mientras `i < str.length`. Después de cada paso incrementa `i` en 1*. En la definición del bucle `for`, entre paréntesis, hay tres expresiones separadas por punto y coma: diff --git a/modules/50-loops/70-for/ru/README.md b/modules/50-loops/70-for/ru/README.md index a45715a7..6f0e61b2 100644 --- a/modules/50-loops/70-for/ru/README.md +++ b/modules/50-loops/70-for/ru/README.md @@ -14,8 +14,6 @@ const reverseString = (str) => { }; ``` -https://replit.com/@hexlet/js-basics-for - Можно читать так: *цикл с индексом `i` повторяется пока `i < str.length` и после каждого шага увеличивает `i` на 1*. В определении цикла `for` в круглых скобках есть три выражения, разделённые точкой с запятой: