diff --git a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
index 8e45bfa86..e9547c4b8 100644
--- a/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/3-editable-div/task.md
@@ -4,10 +4,10 @@ importance: 5
 
 # Editable div
 
-Create a `<div>` that turns into `<textarea>` when clicked.
+Buat sebuah `<div>` yang berubah menjadi`<textarea>` ketika diklik.
 
-The textarea allows to edit the HTML in the `<div>`.
+Textarea memungkinkan untuk mengedit HTML pada `<div>`.
 
-When the user presses `key:Enter` or it loses focus, the `<textarea>` turns back into `<div>`, and its content becomes HTML in `<div>`.
+Ketika user menekan `key:Enter` atau hilang fokus, maka `<textarea>` berubah kembali menjadi `<div>`, dan isinya menjadi HTML di dalam `<div>`.
 
 [demo src="solution"]
diff --git a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.md b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.md
index b5ae45a60..7d0c1e5d3 100644
--- a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.md
+++ b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/solution.md
@@ -1,5 +1,4 @@
-
-1. On click -- replace `innerHTML` of the cell by `<textarea>` with same sizes and no border. Can use JavaScript or CSS to set the right size.
-2. Set `textarea.value` to `td.innerHTML`.
-3. Focus on the textarea.
-4. Show buttons OK/CANCEL under the cell, handle clicks on them.
+1. Saat diklik -- ganti `innerHTML` dari sel `<textarea>` dengan ukuran yang sama dan tanpa border. Bisa menggunakan JavaScript atau CSS untuk mengatur ukuran yang sesuai.
+2. Ubah `textarea.value` ke `td.innerHTML`.
+3. Fokus pada textarea.
+4. Tampilkan tombol OK/CANCEL dibawah sel, tangani klik pada mereka.
diff --git a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
index 2cccea020..5b76304b5 100644
--- a/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/4-edit-td-click/task.md
@@ -4,13 +4,13 @@ importance: 5
 
 # Edit TD on click
 
-Make table cells editable on click.
+Buat sel tabel yang dapat diedit saat diklik.
 
-- On click -- the cell should became "editable" (textarea appears inside), we can change HTML. There should be no resize, all geometry should remain the same.
-- Buttons OK and CANCEL appear below the cell to finish/cancel the editing.
-- Only one cell may be editable at a moment. While a `<td>` is in "edit mode", clicks on other cells are ignored.
-- The table may have many cells. Use event delegation.
+- Saat diklik -- sel akan menjadi "editable" (textarea muncul dalam), kita bisa mengubah HTML. Tidak boleh mengubah ukurannya, semua geometri harus tetap sama..
+- Tombol OK and CANCEL muncul di bawah sel untuk menyelesaikan atau membatalkan proses perubahan.
+- Hanya satu sel yang dapat diedit setiap saatya. Sementara `<td>` dalam "edit mode", klik pada sel lain akan diabaikan.
+- Tabel mungkin memilki banyak sel. Gunakan event _delegation_.
 
-The demo:
+Demo:
 
 [iframe src="solution" height=400]
diff --git a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
index 4d1682176..18c5d2572 100644
--- a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
+++ b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/solution.md
@@ -1,6 +1,6 @@
 
-We can use `mouse.onclick` to handle the click and make the mouse "moveable" with `position:fixed`, then `mouse.onkeydown` to handle arrow keys.
+Kita bisa gunakan `mouse.onclick` untuk menangani klik dan membuat mouse "moveable/bergerak" dengan `position:fixed`, kemudian `mouse.onkeydown` untuk yang menangani tombol panah.
 
-The only pitfall is that `keydown` only triggers on elements with focus. So we need to add `tabindex` to the element.  As we're forbidden to change HTML, we can use `mouse.tabIndex` property for that.
+Satu-satunya jebakan ialah `keydown` hanya memicu pada elemen dengan fokus. Jadi kita perlu untuk menambahkan `tabindex` pada elemen. Karena kita dilarang mengubah HTML, kita bisa gunakan  properti `mouse.tabIndex` untuk itu.
 
-P.S. We also can replace `mouse.onclick` with `mouse.onfocus`.
+P.S. Kita juga bisa ganti `mouse.onclick` dengan `mouse.onfocus`.
diff --git a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
index fc48c21ff..d652db58a 100644
--- a/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
+++ b/2-ui/4-forms-controls/2-focus-blur/5-keyboard-mouse/task.md
@@ -4,9 +4,9 @@ importance: 4
 
 # Keyboard-driven mouse
 
-Focus on the mouse. Then use arrow keys to move it:
+Fokus pada mouse. Lalu gunakan tombol arah untuk menggerakkannya:
 
 [demo src="solution"]
 
-P.S. Don't put event handlers anywhere except the `#mouse` element.
-P.P.S. Don't modify HTML/CSS, the approach should be generic and work with any element.
+P.S. Jangan letakkan event handler dimanapun kecuali pada elemen `#mouse`.
+P.P.S. Jangan modifikasi HTML/CSS, pendekatannya harus umum dan bekerja dengan elemen manapun.
diff --git a/2-ui/4-forms-controls/2-focus-blur/article.md b/2-ui/4-forms-controls/2-focus-blur/article.md
index d4348d25b..c460543e7 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -1,62 +1,65 @@
 # Focusing: focus/blur
 
-An element receives the focus when the user either clicks on it or uses the `key:Tab` key on the keyboard. There's also an `autofocus` HTML attribute that puts the focus onto an element by default when a page loads and other means of getting the focus.
+Sebuah elemen menjadi fokus ketika user mengkliknya atau menggunakan tombol `key:Tab` pada keyboard. Ada juga atribut HTML `autofocus` yang fokus pada sebuah element secara default ketika memuat sebuah halaman dan sebagainya untuk mendapatkan fokus.
 
-Focusing on an element generally means: "prepare to accept the data here", so that's the moment when we can run the code to initialize the required functionality.
+Fokus pada sebuah elemen pada umumnya diartikan: "bersiap untuk terima datanya disini", jadi itu adalah momen ketika kita bisa menjalankan kode untuk di inisiasi kebutuhan fungsionalitas.
 
-The moment of losing the focus ("blur") can be even more important. That's when a user clicks somewhere else or presses `key:Tab` to go to the next form field, or there are other means as well.
+Momen ketika hilang fokus ("blur") bahkan bisa lebih penting. Itu adalah dimana user klik disuatu tempat or menekan `key:Tab` untuk pindah ke kotak selanjutnya, atau dengan cara yang lain.
 
-Losing the focus generally means: "the data has been entered", so we can run the code to check it or even to save it to the server and so on.
+Kehilangan fokus pada umumnya diartikan: "data telah di isi", jadi kita bisa menjalankan kode untuk mengeceknya atau bahkan menyimpannya ke server dan sebagainya.
 
-There are important peculiarities when working with focus events. We'll do the best to cover them further on.
+Ada beberapa keanehan saat bekerja dengan event fokus. Kami akan melakukan yang terbaik untuk membahasnya lebih lanjut.
 
 ## Events focus/blur
 
-The `focus` event is called on focusing, and `blur` -- when the element loses the focus.
+Event `focus` terpanggil/trigger saat sedang fokus, dan event `blur` -- ketika elemen hilang fokus.
 
-Let's use them for validation of an input field.
+Mari gunakan mereka sebagai validasi sebuah kotak input.
 
-In the example below:
+Dalam contoh dibawah:
 
-- The `blur` handler checks if the field has an email entered, and if not -- shows an error.
-- The `focus` handler hides the error message (on `blur` it will be checked again):
+- `blur` cek jika kotak email telah terisi , dan jika tidak -- tampilkan error.
+- `focus` menyembunyikan pesan error (pada `blur` itu akan di cek kembali):
 
 ```html run autorun height=60
 <style>
-  .invalid { border-color: red; }
-  #error { color: red }
+  .invalid {
+    border-color: red;
+  }
+  #error {
+    color: red;
+  }
 </style>
 
-Your email please: <input type="email" id="input">
+Your email please: <input type="email" id="input" />
 
 <div id="error"></div>
 
 <script>
-*!*input.onblur*/!* = function() {
-  if (!input.value.includes('@')) { // not email
-    input.classList.add('invalid');
-    error.innerHTML = 'Please enter a correct email.'
-  }
-};
+  *!*input.onblur*/!* = function() {
+    if (!input.value.includes('@')) { // not email
+      input.classList.add('invalid');
+      error.innerHTML = 'Please enter a correct email.'
+    }
+  };
 
-*!*input.onfocus*/!* = function() {
-  if (this.classList.contains('invalid')) {
-    // remove the "error" indication, because the user wants to re-enter something
-    this.classList.remove('invalid');
-    error.innerHTML = "";
-  }
-};
+  *!*input.onfocus*/!* = function() {
+    if (this.classList.contains('invalid')) {
+      // remove the "error" indication, because the user wants to re-enter something
+      this.classList.remove('invalid');
+      error.innerHTML = "";
+    }
+  };
 </script>
 ```
 
-Modern HTML allows us to do many validations using input attributes: `required`, `pattern` and so on. And sometimes they are just what we need. JavaScript can be used when we want more flexibility. Also we could automatically send the changed value to the server if it's correct.
+Dengan HTML modern kita bisa melakukan beberapa validasi menggunakan atribut input: `required`, `pattern` dan lainnya. Dan terkadang hanya mereka yang kita butuhkan. Kita bisa menggunakan Javascricpt jika ingin fleksibelitas lebih. Juga kita bisa secara otomatis mengirim nilai yang diubah ke server jika nilainya benar.
 
+## Metode focus/blur
 
-## Methods focus/blur
+Metode `elem.focus()` dan `elem.blur()` set/unset fokus pada elemen.
 
-Methods `elem.focus()` and `elem.blur()` set/unset the focus on the element.
-
-For instance, let's make the visitor unable to leave the input if the value is invalid:
+Misalnya, mari buat pengunjung tidak bisa keluar dari input jika nilainya tidak valid:
 
 ```html run autorun height=80
 <style>
@@ -65,73 +68,80 @@ For instance, let's make the visitor unable to leave the input if the value is i
   }
 </style>
 
-Your email please: <input type="email" id="input">
-<input type="text" style="width:220px" placeholder="make email invalid and try to focus here">
+Your email please: <input type="email" id="input" />
+<input
+  type="text"
+  style="width:220px"
+  placeholder="make email invalid and try to focus here"
+/>
 
 <script>
-  input.onblur = function() {
-    if (!this.value.includes('@')) { // not email
-      // show the error
-      this.classList.add("error");
-*!*
-      // ...and put the focus back
-      input.focus();
-*/!*
-    } else {
-      this.classList.remove("error");
-    }
-  };
+    input.onblur = function() {
+      if (!this.value.includes('@')) { // not email
+        // show the error
+        this.classList.add("error");
+  *!*
+        // ...and put the focus back
+        input.focus();
+  */!*
+      } else {
+        this.classList.remove("error");
+      }
+    };
 </script>
 ```
 
-It works in all browsers except Firefox ([bug](https://bugzilla.mozilla.org/show_bug.cgi?id=53579)).
+Itu bekerja pada semua browser kecuali Firefox ([bug](https://bugzilla.mozilla.org/show_bug.cgi?id=53579)).
 
-If we enter something into the input and then try to use `key:Tab` or click away from the `<input>`, then `onblur` returns the focus back.
+Jika kita sedang mengetik/memasukkan sesuatu ke input dan coba menggunakan`key:Tab` atau klik diluar elemen `<input>`, maka `onblur` membuat fokus kembali ke input.
 
-Please note that we can't "prevent losing focus" by calling `event.preventDefault()` in `onblur`, because `onblur` works *after* the element lost the focus.
+Perlu diingat bahwa kita tidak bisa "mencegah hilangnya fokus" dengan memanggil `event.preventDefault()` pada `onblur`, karena `onblur` bekerja saat element hilang fokus.
 
 ```warn header="JavaScript-initiated focus loss"
-A focus loss can occur for many reasons.
+Focus loss bisa terjadi untuk alasan tertentu.
 
-One of them is when the visitor clicks somewhere else. But also JavaScript itself may cause it, for instance:
+Salah satu diantaranya adalah ketika pengunjung klik di tempat lain. Tetapi mungkin Javascript sendiri yang menyebabkannya, Misalya:
 
-- An `alert` moves focus to itself, so it causes the focus loss at the element (`blur` event), and when the `alert` is dismissed, the focus comes back (`focus` event).
-- If an element is removed from DOM, then it also causes the focus loss. If it is reinserted later, then the focus doesn't return.
+- Sebuah `alert` memindahkan fokus untuknya, jadi itu menyebabkan focus loss pada elemen (`blur` event), dan ketika `alert` sudah tidak ada, fokus ada kembali (`focus` event).
+- Jika sebuah elemen dihapus dari DOM, itu juga menyebabkan focus loss. Jika di isi lagi nanti, maka fokus tidak akan kembali.
 
-These features sometimes cause `focus/blur` handlers to misbehave -- to trigger when they are not needed.
+Beberapa fitur ini membuat `focus/blur` handler menjadi misbehave -- trigger disaat mereka tidak diperlukan.
 
-The best recipe is to be careful when using these events. If we want to track user-initiated focus-loss, then we should avoid causing it ourselves.
+Resep yang baik adalah berhati-hati mengunakan event ini. Jika kita ingin melacak focus-loss yang dimulai oleh user, maka kita harus menghidari yang dapat menyebabkan pada kita sendiri.
 ```
-## Allow focusing on any element: tabindex
 
-By default many elements do not support focusing.
+## Memungkinkan fokus pada elemen apapun: tabindex
+
+Secara default banyak elemen yang tidak support focusing.
 
-The list varies a bit between browsers, but one thing is always correct: `focus/blur` support is guaranteed for elements that a visitor can interact with: `<button>`, `<input>`, `<select>`, `<a>` and so on.
+Daftarnya sedikit bervariasi dibeda browser, etapi satu hal yang pasti benar: `focus/blur` dukungannya terjamin untuk elemen-elemen yang pengunjung bisa berinteraksi dengan: `<button>`, `<input>`, `<select>`, `<a>` dan lainnya.
 
-On the other hand, elements that exist to format something, such as `<div>`, `<span>`, `<table>` -- are unfocusable by default. The method `elem.focus()` doesn't work on them, and `focus/blur` events are never triggered.
+Di lain sisi, elemen-elemen yang ada hanya untuk meformat sesuatu seperti `<div>`, `<span>`, `<table>` -- adalah _unfocusable_ secara default. Metode `elem.focus()` tidak bekerja pada mereka, dan `focus/blur` event tidak akan pernah ke trigger.
 
-This can be changed using HTML-attribute `tabindex`.
+Ini bisa diubah dengan menggunakan HTML-attribute `tabindex`.
 
-Any element becomes focusable if it has `tabindex`. The value of the attribute is the order number of the element when `key:Tab` (or something like that) is used to switch between them.
+Elemen apapun menjadi _focusable_ jika ia memilki`tabindex`. Nilai atributnya adalah dari urutan nomor elemen ketika `key:Tab` digunakan untuk berpindah diantara mereka.
 
-That is: if we have two elements, the first has `tabindex="1"`, and the second has `tabindex="2"`, then pressing `key:Tab` while in the first element -- moves the focus into the second one.
+Itu adalah: jika kita memilki 2 elemen, yang pertama memilki `tabindex="1"`, dan yang kedua memilki `tabindex="2"`, lalu menekan `key:Tab` pada saat masih di elemen pertama -- fokus berpindah ke elemen kedua.
 
-The switch order is: elements with `tabindex` from `1` and above go first (in the `tabindex` order), and then elements without `tabindex` (e.g. a regular `<input>`).
+Urutuan pindahnya ialah: elemen dengan `tabindex` dari `1` dan diatasnya menjadi yang pertama (pada urutan`tabindex`), dan baru kemudian elemen tanpa `tabindex` (seperti `<input>` input biasa).
 
-Elements with matching `tabindex` are switched in the document source order (the default order).
+Element dengan `tabindex` yang sesuai berpindah pada urutan sumber dokumen (urutan default).
 
-There are two special values:
+Disana ada dua nilai khusus:
 
-- `tabindex="0"` puts an element among those without `tabindex`. That is, when we switch elements, elements with `tabindex=0` go after elements with `tabindex ≥ 1`.
+- `tabindex="0"` menempatkan sebuah elemen diantara mereka tanpa `tabindex`. Itu ialah, ketika kita pindah elemen, elemen dengan `tabindex=0` berpindah setelah elemen dengan `tabindex ≥ 1`.
 
-    Usually it's used to make an element focusable, but keep the default switching order. To make an element a part of the form on par with `<input>`.
+  Biasanya itu digunakan agar sebuah elemen menjadi _focusable_, tapi tetap memerhatikan urutan perpindahan default. Untuk membuat sebuah elemen menjadi bagian dari form yang setara`<input>`.
 
-- `tabindex="-1"` allows only programmatic focusing on an element. The `key:Tab` key ignores such elements, but method `elem.focus()` works.
+- `tabindex="-1"` hanya membolehkan _programmatic focusing_ pada sebuah elemen. Kunci `key:Tab` mengabaikan elemen seperti itu, akan tetapi metode `elem.focus()` dapat berfungsi.
 
-For instance, here's a list. Click the first item and press `key:Tab`:
+Misalnya, ada list elemen. Klik item pertama dan tekan `key:Tab`:
 
 ```html autorun no-beautify
-Click the first item and press Tab. Keep track of the order. Please note that many subsequent Tabs can move the focus out of the iframe in the example.
+Klik pada elemen pertama dan tekan tab. Perhatikan pada urutan. Harap perhatikan
+bahwa banyak Tab berikutnya yang dapat memindahkan fokus dari iframe dalam
+contoh.
 <ul>
   <li tabindex="1">One</li>
   <li tabindex="0">Zero</li>
@@ -140,22 +150,25 @@ Click the first item and press Tab. Keep track of the order. Please note that ma
 </ul>
 
 <style>
-  li { cursor: pointer; }
-  :focus { outline: 1px dashed green; }
+  li {
+    cursor: pointer;
+  }
+  :focus {
+    outline: 1px dashed green;
+  }
 </style>
 ```
 
-The order is like this: `1 - 2 - 0`. Normally, `<li>` does not support focusing, but `tabindex` full enables it, along with events and styling with `:focus`.
+Urutannya sepeti ini: `1 - 2 - 0`. Normalnya, `<li>` tidak support _focusing_, tetapi dengan `tabindex`membuatnya _focusable_, berserta dengan eventnya dan styling `:focus`.
 
-```smart header="The property `elem.tabIndex` works too"
-We can add `tabindex` from JavaScript by using the `elem.tabIndex` property. That has the same effect.
-```
+```smart header="The property `elem.tabIndex`juga dapat bekerja" Kita bisa menambahkan`tabindex`dari JavaScript dengan menggunakan properti`elem.tabIndex`. Itu menghasilkan efek yang sama.
 
-## Delegation: focusin/focusout
+````
 
-Events `focus` and `blur` do not bubble.
+## Delegation: focusin/focusout
 
-For instance, we can't put `onfocus` on the `<form>` to highlight it, like this:
+Events `focus` and `blur` tidak mengelembung(bubble)./
+Misalnya, kita tidak bisa letak `onfocus` pada `<form>` untuk menghighlight-nya, seperti ini:
 
 ```html autorun height=80
 <!-- on focusing in the form -- add the class -->
@@ -165,61 +178,69 @@ For instance, we can't put `onfocus` on the `<form>` to highlight it, like this:
 </form>
 
 <style> .focused { outline: 1px solid red; } </style>
-```
+````
 
-The example above doesn't work, because when user focuses on an `<input>`, the `focus` event triggers on that input only. It doesn't bubble up. So `form.onfocus` never triggers.
+Contoh diatas tidak akan bekerja, karena ketika sedang fokus pada sebuah `<input>`, event `focus` akan trigger hanya pada input tersebut. Ia tidak mengelembung ke atas(bubble up). Jadi `form.onfocus` tidak akan pernah trigger.
 
-There are two solutions.
+Hanya ada dua solusi.
 
-First, there's a funny historical feature: `focus/blur` do not bubble up, but propagate down on the capturing phase.
+Pertama, ada satu sejarah lucu dengan fitur: `focus/blur` yang tidak mengelembung ke atas(bubble up), tetapi merambat ke bawah saat _capturing phase_.
 
-This will work:
+Ini akan bekerja:
 
 ```html autorun height=80
 <form id="form">
-  <input type="text" name="name" value="Name">
-  <input type="text" name="surname" value="Surname">
+  <input type="text" name="name" value="Name" />
+  <input type="text" name="surname" value="Surname" />
 </form>
 
-<style> .focused { outline: 1px solid red; } </style>
+<style>
+  .focused {
+    outline: 1px solid red;
+  }
+</style>
 
 <script>
-*!*
-  // put the handler on capturing phase (last argument true)
-  form.addEventListener("focus", () => form.classList.add('focused'), true);
-  form.addEventListener("blur", () => form.classList.remove('focused'), true);
-*/!*
+  *!*
+    // meletakkan handler pada capturing phase (argumenterakhir set menjadit true)
+    form.addEventListener("focus", () => form.classList.add('focused'), true);
+    form.addEventListener("blur", () => form.classList.remove('focused'), true);
+  */!*
 </script>
 ```
 
-Second, there are `focusin` and `focusout` events -- exactly the same as `focus/blur`, but they bubble.
+Kedua, ada event `focusin` dan `focusout` -- persis sama dengan`focus/blur`, tetapi mereka mengelembung(bubble).
+Ingat bahwa mereka perlu di definisi menggunakan `elem.addEventListener`, bukan `on<event>`.
 
-Note that they must be assigned using `elem.addEventListener`, not `on<event>`.
-
-So here's another working variant:
+Jadi ini adalah cara lain yang dapat bekerja:
 
 ```html autorun height=80
 <form id="form">
-  <input type="text" name="name" value="Name">
-  <input type="text" name="surname" value="Surname">
+  <input type="text" name="name" value="Name" />
+  <input type="text" name="surname" value="Surname" />
 </form>
 
-<style> .focused { outline: 1px solid red; } </style>
+<style>
+  .focused {
+    outline: 1px solid red;
+  }
+</style>
 
 <script>
-*!*
-  form.addEventListener("focusin", () => form.classList.add('focused'));
-  form.addEventListener("focusout", () => form.classList.remove('focused'));
-*/!*
+  *!*
+    form.addEventListener("focusin", () => form.classList.add('focused'));
+    form.addEventListener("focusout", () => form.classList.remove('focused'));
+  */!*
 </script>
 ```
 
-## Summary
+## Kesimpulan
+
+Event `focus` dan `blur` trigger pada saat sebuah elemen fokus dan hilang fokus.
 
-Events `focus` and `blur` trigger on an element focusing/losing focus.
+Keistimewaan mereka adalah:
 
-Their specials are:
-- They do not bubble. Can use capturing state instead or `focusin/focusout`.
-- Most elements do not support focus by default. Use `tabindex` to make anything focusable.
+- Mereka tidak mengelembung(bubble). Gantinya bisa menggunakan _capturing state_ atau `focusin/focusout`.
+- Kebanyakan elemen tidak mendukung fokus secara default. Gunakan `tabindex` untuk membuat elemen manapapun menjadi _focusable_.
 
-The current focused element is available as `document.activeElement`.
+Elemen fokus saat ini tersedia sebagai `document.activeElement`.