fix(es): update stale jsxref references

files/es/conflicting/web/javascript/reference/global_objects/object/tostring/index.md

@@ -61,7 +61,7 @@ Cada tipo fundamental de JavaScript tiene su propio método `toSource()`. Éstos
 - {{jsxref("Function.prototype.toString()", "Function.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Function")}} object.
 - {{jsxref("Number.prototype.toString()", "Number.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Number")}} object.
 - {{jsxref("RegExp.prototype.toString()", "RegExp.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("RegExp")}} object.
-- {{jsxref("SIMD.toSource()", "SIMD.%type%.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("SIMD")}} objects.
+- `SIMD.%type%.prototype.toSource()` {{non-standard_inline}} — `SIMD` objects.
 - {{jsxref("String.prototype.toString()", "String.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("String")}} object.
 - {{jsxref("Symbol.prototype.toString()", "Symbol.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Symbol")}} object.
 - `Math.toSource()` — Regrsa la cadena "Math".

files/es/glossary/primitive/index.md

@@ -72,7 +72,7 @@ console.log(foo); // 5
 - Antes de ejecutar las declaraciones dentro del cuerpo de las funciones, **JavaScript toma una copia del argumento originalmente pasado** (que es un primitivo) y crea una copia local. Estas copias, que existen solo dentro del ámbito de las funciones, son accesibles a través de los identificadores que especificaste en las definiciones de las funciones (`num` para `addTwo`, `foo` para `addTwo_v2`)
 - Luego, se ejecutan las instrucciones de las funciones:
   - En la primera función, se creó una variable `num` local. ¡Estas aumentando su valor en 2, no el valor original de `foo`!
-  - En la segunda función, se creó una variable `foo` local. ¡Esto incrementa su valor en 2, no el valor original (externo) de `foo`!, además, en esta situación, no se puede acceder directamente a la variable `foo` externa. Esto se debe al alcance léxico de JavaScript y al ensombrecimiento de variables resultante. El `foo` local oculta al `foo` externo. Para obtener más información, consulta {{JSxRef("Closures", "Cierres")}}. (Ten en cuenta que `window.foo` aún se podría usar para acceder a la variable `foo` externa).
+  - En la segunda función, se creó una variable `foo` local. ¡Esto incrementa su valor en 2, no el valor original (externo) de `foo`!, además, en esta situación, no se puede acceder directamente a la variable `foo` externa. Esto se debe al alcance léxico de JavaScript y al ensombrecimiento de variables resultante. El `foo` local oculta al `foo` externo. Para obtener más información, consulta [Cierres](/es/docs/Web/JavaScript/Guide/Closures). (Ten en cuenta que `window.foo` aún se podría usar para acceder a la variable `foo` externa).
 
 - En conclusión, cualquier cambio dentro de tus funciones **no** afectará a la `foo` original en absoluto, ya que estas modificando **copias** de la misma.
 

files/es/mozilla/firefox/releases/57/index.md

@@ -54,9 +54,9 @@ _No hay ningún cambio._
 
 ### JavaScript
 
-- El bucle no estándar {{jsxref("Statements/for_each...in", "for each...in")}} (E4X) fue eliminado. En su lugar, utilícese {{jsxref("Statements/for...of", "for...of")}} y consúltese [Atención: los bucles de JavaScript 1.6 «for-each-in» son obsoletos](/es/docs/Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated) para obtener ayuda en la migración. ([Error 1083470 en Firefox](https://bugzil.la/1083470)).
-- Se marcaron como obsoletos los métodos {{jsxref("Object.prototype.watch()")}} y {{jsxref("Object.unwatch", "unwatch()")}}. Se emitirá una alerta si se utilizan y serán eliminados en el futuro próximo ([Error 934669 en Firefox](https://bugzil.la/934669)).
-- Se eliminaron los objetos {{jsxref("Iterator")}} y {{jsxref("StopIteration")}} y el protocolo de iteración heredado ([Error 1098412 en Firefox](https://bugzil.la/1098412)).
+- El bucle no estándar `for each...in` (E4X) fue eliminado. En su lugar, utilícese {{jsxref("Statements/for...of", "for...of")}} y consúltese [Atención: los bucles de JavaScript 1.6 «for-each-in» son obsoletos](/es/docs/Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated) para obtener ayuda en la migración. ([Error 1083470 en Firefox](https://bugzil.la/1083470)).
+- Se marcaron como obsoletos los métodos `Object.prototype.watch()` y `unwatch()`. Se emitirá una alerta si se utilizan y serán eliminados en el futuro próximo ([Error 934669 en Firefox](https://bugzil.la/934669)).
+- Se eliminaron los objetos {{jsxref("Iterator")}} y `StopIteration` y el protocolo de iteración heredado ([Error 1098412 en Firefox](https://bugzil.la/1098412)).
 
 ### API
 

files/es/web/javascript/guide/control_flow_and_error_handling/index.md

@@ -7,7 +7,7 @@ slug: Web/JavaScript/Guide/Control_flow_and_error_handling
 
 JavaScript admite un compacto conjunto de declaraciones, específicamente declaraciones de control de flujo, que puedes utilizar para incorporar una gran cantidad de interactividad en tu aplicación. Este capítulo proporciona una descripción de estas declaraciones.
 
-La {{JSxRef("Sentencias", "referencia de JavaScript")}} contiene detalles exhaustivos sobre las declaraciones de este capítulo. El carácter de punto y coma (`;`) se utiliza para separar declaraciones en código JavaScript.
+La {{JSxRef("Statements", "referencia de JavaScript")}} contiene detalles exhaustivos sobre las declaraciones de este capítulo. El carácter de punto y coma (`;`) se utiliza para separar declaraciones en código JavaScript.
 
 Todas las expresiones e instrucciones de JavaScript también son una declaración. Consulta [Expresiones y operadores](/es/docs/Web/JavaScript/Guide/Expressions_and_operators) para obtener información completa sobre las expresiones.
 

files/es/web/javascript/guide/expressions_and_operators/index.md

@@ -7,7 +7,7 @@ slug: Web/JavaScript/Guide/Expressions_and_operators
 
 Este capítulo describe las expresiones y los operadores de JavaScript, incluyendo los de asignación, comparación, aritméticos, bit a bit, lógicos, ternarios, de cadena y otros.
 
-También se encuentra disponible una lista completa y detallada de operadores y expresiones en la {{JSxRef("Operadores", "referencia")}}.
+También se encuentra disponible una lista completa y detallada de operadores y expresiones en la {{JSxRef("Operators", "referencia")}}.
 
 ## Operadores
 
@@ -118,16 +118,16 @@ var var1 = 3;
 var var2 = 4;
 ```
 
-| Operador                                                                                    | Descripción                                                                                                                                                                   | Ejemplos que devuelven `true`              |
-| ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
-| {{JSxRef("Operators", "Igual", "#Igualdad")}} (`==`)                                        | Devuelve `true` si los operandos son iguales.                                                                                                                                 | `3 == var1`<br>`"3" == var1`<br>`3 == '3'` |
-| {{JSxRef("Operators", "No es igual", "#Desigualdad")}} (`!=`)                               | Devuelve `true` si los operandos _no_ son iguales.                                                                                                                            | `var1 != 4`<br>`var2 != "3"`               |
-| {{JSxRef("Operators", "Estrictamente igual", "#Identidad")}} (`===`)                        | Devuelve `true` si los operandos son iguales y del mismo tipo. Consulta también {{JSxRef("Object.is")}} y {{JSxRef("Equality_comparisons_and_sameness", "similitud en JS")}}. | `3 === var1`                               |
-| {{JSxRef("Operators", "Desigualdad estricta", "#No_Identidad")}} (`!==`)                    | Devuelve `true` si los operandos son del mismo tipo pero no iguales, o son de diferente tipo.                                                                                 | `var1 !== "3"`<br>`3 !== '3'`              |
-| {{JSxRef("/Operadores/Comparison_Operators", "Mayor que", "#Mayor_que_el_operador")}} (`>`) | Devuelve `true` si el operando izquierdo es mayor que el operando derecho.                                                                                                    | `var2 > var1 "12" > 2`                     |
-| {{JSxRef("Operators", "Mayor o igual que", "#Operador_mayor_que_o_igual")}} (`>=`)          | Devuelve `true` si el operando izquierdo es mayor o igual que el operando derecho.                                                                                            | `var2 >= var1 var1 >= 3`                   |
-| {{JSxRef("Operators", "Menor que", "#Operador_menor_que")}} (`<`)                           | Devuelve `true` si el operando izquierdo es menor que el operando derecho.                                                                                                    | `var1 < var2`<br>`"2" < 12`                |
-| {{JSxRef("Operators", "Menor o igual", "#Operador_menor_que_o_igual")}} (`<=`)              | Devuelve `true` si el operando izquierdo es menor o igual que el operando derecho.                                                                                            | `var1 <= var2 var2 <= 5`                   |
+| Operador                                                                           | Descripción                                                                                                                                                                                   | Ejemplos que devuelven `true`              |
+| ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| {{JSxRef("Operators", "Igual", "#Igualdad")}} (`==`)                               | Devuelve `true` si los operandos son iguales.                                                                                                                                                 | `3 == var1`<br>`"3" == var1`<br>`3 == '3'` |
+| {{JSxRef("Operators", "No es igual", "#Desigualdad")}} (`!=`)                      | Devuelve `true` si los operandos _no_ son iguales.                                                                                                                                            | `var1 != 4`<br>`var2 != "3"`               |
+| {{JSxRef("Operators", "Estrictamente igual", "#Identidad")}} (`===`)               | Devuelve `true` si los operandos son iguales y del mismo tipo. Consulta también {{JSxRef("Object.is")}} y [similitud en JS](/es/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness). | `3 === var1`                               |
+| {{JSxRef("Operators", "Desigualdad estricta", "#No_Identidad")}} (`!==`)           | Devuelve `true` si los operandos son del mismo tipo pero no iguales, o son de diferente tipo.                                                                                                 | `var1 !== "3"`<br>`3 !== '3'`              |
+| {{JSxRef("Operators/Greater_than", "Mayor que")}} (`>`)                            | Devuelve `true` si el operando izquierdo es mayor que el operando derecho.                                                                                                                    | `var2 > var1 "12" > 2`                     |
+| {{JSxRef("Operators", "Mayor o igual que", "#Operador_mayor_que_o_igual")}} (`>=`) | Devuelve `true` si el operando izquierdo es mayor o igual que el operando derecho.                                                                                                            | `var2 >= var1 var1 >= 3`                   |
+| {{JSxRef("Operators", "Menor que", "#Operador_menor_que")}} (`<`)                  | Devuelve `true` si el operando izquierdo es menor que el operando derecho.                                                                                                                    | `var1 < var2`<br>`"2" < 12`                |
+| {{JSxRef("Operators", "Menor o igual", "#Operador_menor_que_o_igual")}} (`<=`)     | Devuelve `true` si el operando izquierdo es menor o igual que el operando derecho.                                                                                                            | `var1 <= var2 var2 <= 5`                   |
 
 > [!NOTE]
 > (**=>**) no es un operador, sino la notación para {{JSxRef("Functions/Arrow_functions", "Funciones flecha")}}.

files/es/web/javascript/guide/functions/index.md

@@ -7,7 +7,7 @@ slug: Web/JavaScript/Guide/Functions
 
 Las funciones son uno de los bloques de construcción fundamentales en JavaScript. Una función en JavaScript es similar a un procedimiento — un conjunto de instrucciones que realiza una tarea o calcula un valor, pero para que un procedimiento califique como función, debe tomar alguna entrada y devolver una salida donde hay alguna relación obvia entre la entrada y la salida. Para usar una función, debes definirla en algún lugar del ámbito desde el que deseas llamarla.
 
-Consulta también el {{JSxRef("Funciones", "capítulo de referencia exhaustivo sobre funciones de JavaScript")}} para conocer los detalles.
+Consulta también el {{JSxRef("Functions", "capítulo de referencia exhaustivo sobre funciones de JavaScript")}} para conocer los detalles.
 
 ## Definir funciones