From 3cad6627403fb2feadcbc2d951e91e999039c0f3 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:51:21 +0300
Subject: [PATCH 01/11] =?UTF-8?q?feat(1-js):=20Changed=20all=20apostrophes?=
 =?UTF-8?q?=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 1-js/01-getting-started/1-intro/article.md    |  14 +-
 1-js/01-getting-started/4-devtools/article.md |   2 +-
 1-js/02-first-steps/02-structure/article.md   |   4 +-
 .../2-declare-variables/solution.md           |   6 +-
 1-js/02-first-steps/04-variables/article.md   |   6 +-
 1-js/02-first-steps/05-types/article.md       |  26 ++--
 .../06-alert-prompt-confirm/article.md        |   2 +-
 .../07-type-conversions/article.md            |   8 +-
 1-js/02-first-steps/08-operators/article.md   |  16 +-
 1-js/02-first-steps/09-comparison/article.md  |   2 +-
 1-js/02-first-steps/10-ifelse/article.md      |   4 +-
 .../11-logical-operators/article.md           |   6 +-
 .../12-nullish-coalescing-operator/article.md |  16 +-
 .../6-repeat-until-correct/task.md            |   2 +-
 .../solution.md                               |   2 +-
 .../15-function-basics/article.md             |  18 +--
 .../18-javascript-specials/article.md         |  16 +-
 .../01-debugging-chrome/article.md            |   2 +-
 1-js/03-code-quality/04-ninja-code/article.md |  30 ++--
 .../3-pow-test-wrong/solution.md              |   2 +-
 .../05-testing-mocha/article.md               |   4 +-
 1-js/03-code-quality/06-polyfills/article.md  |   4 +-
 .../01-object/2-hello-object/task.md          |   4 +-
 .../01-object/3-is-empty/solution.md          |   2 +-
 .../01-object/3-is-empty/task.md              |   2 +-
 .../01-object/5-sum-object/task.md            |   6 +-
 .../01-object/8-multiply-numeric/task.md      |   4 +-
 1-js/04-object-basics/01-object/article.md    |  82 +++++-----
 .../02-object-copy/article.md                 |  78 +++++-----
 .../03-garbage-collection/article.md          |  62 ++++----
 .../4-object-property-this/solution.md        |   6 +-
 .../4-object-property-this/task.md            |   4 +-
 .../04-object-methods/7-calculator/task.md    |   2 +-
 .../8-chain-calls/solution.md                 |   2 +-
 .../04-object-methods/article.md              |  68 ++++-----
 .../1-two-functions-one-object/solution.md    |   4 +-
 .../1-two-functions-one-object/task.md        |   2 +-
 .../2-calculator-constructor/task.md          |   4 +-
 .../06-constructor-new/3-accumulator/task.md  |   2 +-
 .../06-constructor-new/article.md             |  48 +++---
 .../07-optional-chaining/article.md           |  22 +--
 1-js/04-object-basics/08-symbol/article.md    |  38 ++---
 .../09-object-toprimitive/article.md          |  80 +++++-----
 1-js/04-object-basics/index.md                |   2 +-
 .../01-primitives-methods/article.md          |  36 ++---
 .../9-random-int-min-max/solution.md          |   2 +-
 1-js/05-data-types/02-number/article.md       |  18 +--
 .../04-array/1-item-value/solution.md         |   2 +-
 .../04-array/3-call-array-this/solution.md    |   2 +-
 1-js/05-data-types/04-array/article.md        |  52 +++----
 .../05-array-methods/10-average-age/task.md   |   2 +-
 .../05-array-methods/12-reduce-object/task.md |   4 +-
 .../6-array-get-names/task.md                 |   2 +-
 .../05-data-types/05-array-methods/article.md |   2 +-
 1-js/05-data-types/06-iterable/article.md     |  82 +++++-----
 1-js/05-data-types/07-map-set/article.md      |  76 +++++-----
 .../01-recipients-read/solution.md            |   4 +-
 .../01-recipients-read/task.md                |   4 +-
 .../02-recipients-when-read/solution.md       |   2 +-
 .../02-recipients-when-read/task.md           |   4 +-
 .../08-weakmap-weakset/article.md             |  84 +++++------
 .../01-sum-salaries/task.md                   |   4 +-
 .../02-count-properties/task.md               |   2 +-
 .../09-keys-values-entries/article.md         |  18 +--
 .../1-destruct-user/task.md                   |   2 +-
 .../6-max-salary/task.md                      |   6 +-
 .../10-destructuring-assignment/article.md    |  58 +++----
 .../11-date/1-new-date/solution.md            |   2 +-
 1-js/05-data-types/11-date/1-new-date/task.md |   2 +-
 .../11-date/6-get-seconds-today/solution.md   |   2 +-
 .../8-format-date-relative/solution.md        |   2 +-
 1-js/05-data-types/11-date/article.md         |  30 ++--
 .../12-json/1-serialize-object/task.md        |   2 +-
 .../2-serialize-event-circular/task.md        |   2 +-
 1-js/05-data-types/12-json/article.md         |  68 ++++-----
 .../01-recursion/01-sum-to/solution.md        |   2 +-
 .../03-fibonacci-numbers/solution.md          |   4 +-
 .../01-recursion/03-fibonacci-numbers/task.md |   2 +-
 .../04-output-single-linked-list/task.md      |   4 +-
 .../solution.md                               |   4 +-
 .../task.md                                   |   4 +-
 .../01-recursion/article.md                   |  58 +++----
 .../02-rest-parameters-spread/article.md      |  22 +--
 .../4-counter-object-independent/task.md      |   2 +-
 .../03-closure/9-sort-by-field/task.md        |   4 +-
 .../03-closure/article.md                     |  50 +++---
 1-js/06-advanced-functions/04-var/article.md  |   4 +-
 .../05-global-object/article.md               |  32 ++--
 .../5-sum-many-brackets/solution.md           |   4 +-
 .../06-function-object/article.md             |  30 ++--
 .../07-new-function/article.md                |   2 +-
 .../08-settimeout-setinterval/article.md      |  20 +--
 .../04-throttle/solution.md                   |   4 +-
 .../09-call-apply-decorators/article.md       |  36 ++---
 .../2-write-to-object-after-bind/solution.md  |   2 +-
 .../2-write-to-object-after-bind/task.md      |   2 +-
 .../10-bind/3-second-bind/solution.md         |   4 +-
 .../10-bind/3-second-bind/task.md             |   4 +-
 .../solution.md                               |   2 +-
 .../4-function-property-after-bind/task.md    |   2 +-
 .../10-bind/5-question-use-bind/solution.md   |   4 +-
 .../10-bind/6-ask-partial/task.md             |   2 +-
 1-js/06-advanced-functions/10-bind/article.md |  56 +++----
 .../12-arrow-functions/article.md             |   8 +-
 .../01-property-descriptors/article.md        |  32 ++--
 .../02-property-accessors/article.md          |  20 +--
 1-js/07-object-properties/index.md            |   4 +-
 .../1-property-after-delete/task.md           |   2 +-
 .../2-search-algorithm/solution.md            |   4 +-
 .../2-search-algorithm/task.md                |   2 +-
 .../3-proto-and-this/solution.md              |   2 +-
 .../3-proto-and-this/task.md                  |   4 +-
 .../4-hamster-proto/solution.md               |  20 +--
 .../4-hamster-proto/task.md                   |   6 +-
 .../01-prototype-inheritance/article.md       |  70 ++++-----
 .../1-changing-prototype/solution.md          |   8 +-
 .../1-changing-prototype/task.md              |   2 +-
 .../4-new-object-same-constructor/solution.md |  12 +-
 .../4-new-object-same-constructor/task.md     |   6 +-
 .../02-function-prototype/article.md          |  30 ++--
 .../2-defer-to-prototype-extended/solution.md |   4 +-
 .../03-native-prototypes/article.md           |  44 +++---
 .../2-dictionary-tostring/solution.md         |   4 +-
 .../2-dictionary-tostring/task.md             |   8 +-
 .../3-compare-calls/solution.md               |   2 +-
 .../3-compare-calls/task.md                   |   2 +-
 .../04-prototype-methods/article.md           |  68 ++++-----
 1-js/09-classes/01-class/article.md           |  42 +++---
 .../1-class-constructor-error/task.md         |   2 +-
 .../02-class-inheritance/article.md           |  10 +-
 .../3-class-extend-object/task.md             |   4 +-
 .../03-static-properties-methods/article.md   |  14 +-
 .../article.md                                |  20 +--
 1-js/09-classes/05-extend-natives/article.md  |  10 +-
 1-js/09-classes/06-instanceof/article.md      |  24 +--
 1-js/09-classes/07-mixins/article.md          |  16 +-
 1-js/10-error-handling/1-try-catch/article.md |  40 ++---
 .../2-custom-errors/article.md                |  20 +--
 1-js/11-async/02-promise-basics/article.md    |  26 ++--
 1-js/11-async/03-promise-chaining/article.md  |  18 +--
 .../04-promise-error-handling/article.md      |   8 +-
 1-js/11-async/05-promise-api/article.md       |  20 +--
 1-js/11-async/07-microtask-queue/article.md   |   4 +-
 .../02-rewrite-async-2/solution.md            |   6 +-
 .../08-async-await/02-rewrite-async-2/task.md |   6 +-
 .../03-async-from-regular/task.md             |   2 +-
 1-js/11-async/08-async-await/article.md       |   6 +-
 .../1-generators/article.md                   |  36 ++---
 .../2-async-iterators-generators/article.md   |  32 ++--
 1-js/13-modules/01-modules-intro/article.md   |  44 +++---
 1-js/13-modules/02-import-export/article.md   |  20 +--
 .../03-modules-dynamic-imports/article.md     |   6 +-
 .../01-proxy/01-error-nonexisting/task.md     |   2 +-
 .../01-proxy/03-observable/solution.md        |   4 +-
 .../99-js-misc/01-proxy/03-observable/task.md |   4 +-
 1-js/99-js-misc/01-proxy/article.md           | 142 +++++++++---------
 .../03-currying-partials/article.md           |   4 +-
 1-js/99-js-misc/04-reference-type/article.md  |  14 +-
 1-js/99-js-misc/06-unicode/article.md         |   4 +-
 159 files changed, 1317 insertions(+), 1317 deletions(-)

diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index e1639fef4..84e5164f1 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -1,6 +1,6 @@
 # Вступ до JavaScript
 
-Давайте розглянемо, що такого особливого в JavaScript, чого ми можемо досягти за її допомогою та які ще технології пов’язані з нею.
+Давайте розглянемо, що такого особливого в JavaScript, чого ми можемо досягти за її допомогою та які ще технології пов'язані з нею.
 
 ## Що таке JavaScript?
 
@@ -28,7 +28,7 @@
 - [SpiderMonkey](https://uk.wikipedia.org/wiki/SpiderMonkey) -- в Firefox.
 - ...Є також інші кодові назви як "Chakra" для IE, "JavaScriptCore", "Nitro" і "SquirrelFish" для Safari, та інші.
 
-Терміни вище добре було б запам’ятати, оскільки вони використовуються в статтях розробників на просторах інтернету. Ми також будемо їх використовувати. Наприклад, якщо "можливість X підтримується в V8", то, імовірно, вона працюватиме в Chrome, Opera та Edge.
+Терміни вище добре було б запам'ятати, оскільки вони використовуються в статтях розробників на просторах інтернету. Ми також будемо їх використовувати. Наприклад, якщо "можливість X підтримується в V8", то, імовірно, вона працюватиме в Chrome, Opera та Edge.
 
 ```smart header="Як рушії працюють?"
 
@@ -43,11 +43,11 @@
 
 ## Що може вбудований у браузер JavaScript?
 
-Сучасний JavaScript -- це "безпечна" мова програмування. Вона не надає низькорівневого доступу до пам’яті чи процесора, оскільки була створена для браузерів, які цього не потребують.
+Сучасний JavaScript -- це "безпечна" мова програмування. Вона не надає низькорівневого доступу до пам'яті чи процесора, оскільки була створена для браузерів, які цього не потребують.
 
 Можливості JavaScript значно залежать від середовища, у якому виконується скрипт. Наприклад, [Node.js](https://uk.wikipedia.org/wiki/Node.js) підтримує функції, які дозволяють JavaScript читати/записувати довільні файли, здійснювати мережеві запити тощо.
 
-Вбудована в браузер JavaScript може робити все, що пов’язано з управлінням вебсторінками, взаємодією з користувачем та вебсервером.
+Вбудована в браузер JavaScript може робити все, що пов'язано з управлінням вебсторінками, взаємодією з користувачем та вебсервером.
 
 Наприклад, JavaScript може:
 
@@ -55,11 +55,11 @@
 - Реагувати на дії користувача, опрацьовувати натискання миші, переміщення вказівника, натискання на клавіші клавіатури.
 - Відправляти запити через мережу до віддалених серверів, завантажувати та відвантажувати файли (так звані технології [AJAX](https://uk.wikipedia.org/wiki/AJAX) і [COMET](https://uk.wikipedia.org/wiki/Comet_(програмування))).
 - Отримувати і надсилати [куки](https://uk.wikipedia.org/wiki/Куки), ставити запитання відвідувачам, показувати повідомлення.
-- Запам’ятовувати дані на стороні клієнта ("[local storage](https://developer.mozilla.org/uk/docs/Web/API/Window/localStorage)"), які будуть доступні в майбутніх сесіях на цьому вебсайті.
+- Запам'ятовувати дані на стороні клієнта ("[local storage](https://developer.mozilla.org/uk/docs/Web/API/Window/localStorage)"), які будуть доступні в майбутніх сесіях на цьому вебсайті.
 
 ## Що НЕ може JavaScript?
 
-Можливості JavaScript у браузері обмежені для безпеки користувача. Мета полягає в тому, щоб небезпечні вебсторінки не мали доступу до приватної інформації та не могли пошкодити інформацію на комп’ютері користувача.
+Можливості JavaScript у браузері обмежені для безпеки користувача. Мета полягає в тому, щоб небезпечні вебсторінки не мали доступу до приватної інформації та не могли пошкодити інформацію на комп'ютері користувача.
 
 Приклади таких обмежень:
 
@@ -100,7 +100,7 @@ JavaScript -- це єдина браузерна технологія, яка с
 
 Цього слід очікувати, тому що проєкти та вимоги різні для кожного.
 
-Останнім часом з’явилося безліч нових мов, які *транспілюються* (конвертуються) в JavaScript перед виконанням у браузері.
+Останнім часом з'явилося безліч нових мов, які *транспілюються* (конвертуються) в JavaScript перед виконанням у браузері.
 
 Сучасні інструменти роблять транспіляцію дуже швидкою та прозорою, дозволяючи розробникам писати код іншою мовою й автоматично конвертувати його "під капотом".
 
diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md
index 5747a8f90..5573ff78f 100644
--- a/1-js/01-getting-started/4-devtools/article.md
+++ b/1-js/01-getting-started/4-devtools/article.md
@@ -53,7 +53,7 @@ Safari (стандартний браузер у macOS, не підтримує
 
 ![safari](safari.png)
 
-Тепер комбінація клавіш `key:Cmd+Opt+C` може переключати консоль. Також зауважте, що з’явився новий пункт "Розробка" у верхньому меню. Це меню має багато команд та опцій.
+Тепер комбінація клавіш `key:Cmd+Opt+C` може переключати консоль. Також зауважте, що з'явився новий пункт "Розробка" у верхньому меню. Це меню має багато команд та опцій.
 
 ## Підсумки
 
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 37a05a35d..cfaf136cb 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -61,7 +61,7 @@ alert("Привіт");
 [1, 2].forEach(alert);
 ```
 
-Поки що не задумуйтеся, що означають квадратні дужки `[]` і `forEach`. Ми вивчимо їх пізніше. Зараз просто запам’ятайте результат виконання коду: спочатку виведеться `Привіт`, далі `1`, а потім `2`.
+Поки що не задумуйтеся, що означають квадратні дужки `[]` і `forEach`. Ми вивчимо їх пізніше. Зараз просто запам'ятайте результат виконання коду: спочатку виведеться `Привіт`, далі `1`, а потім `2`.
 
 А тепер видалимо крапку з комою після першого `alert`:
 
@@ -83,7 +83,7 @@ alert("Привіт")
 alert("Привіт")[1, 2].forEach(alert);
 ```
 
-Виглядає дивно, чи не так? У цьому випадку таке об’єднання неправильне. Щоби код правильно працював, нам потрібно поставити крапку з комою після `alert`.
+Виглядає дивно, чи не так? У цьому випадку таке об'єднання неправильне. Щоби код правильно працював, нам потрібно поставити крапку з комою після `alert`.
 
 Це може статися в інших випадках.
 ````
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
index b6cff1ea7..aa7ac1e19 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
@@ -6,15 +6,15 @@
 let ourPlanetName = "Земля";
 ```
 
-Зверніть увагу, ми могли використати коротше ім’я `planet`, але тоді буде незрозуміло, яку планету ми маємо на увазі. Краще описати вміст змінної детальніше. Принаймні до тих пір, поки ім’я змінної неСтанеЗанадтоДовгим.
+Зверніть увагу, ми могли використати коротше ім'я `planet`, але тоді буде незрозуміло, яку планету ми маємо на увазі. Краще описати вміст змінної детальніше. Принаймні до тих пір, поки ім'я змінної неСтанеЗанадтоДовгим.
 
-## Ім’я поточного відвідувача
+## Ім'я поточного відвідувача
 
 ```js
 let currentUserName = "Іван";
 ```
 
-Знову ж таки, ми можемо скоротити ім’я до `userName`, якщо ми точно знатимемо, що це поточний відвідувач.
+Знову ж таки, ми можемо скоротити ім'я до `userName`, якщо ми точно знатимемо, що це поточний відвідувач.
 
 Сучасні редактори й автодоповнювачі дозволяють легко писати довгі імена змінних. Не економте букв. Імена з трьох слів цілком нормальні.
 
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index 74c8fe9cf..e0edc6360 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -162,7 +162,7 @@ let message = "Той"; // SyntaxError: 'message' has already been declared
 
 В JavaScript є два обмеження, які стосуються імен змінних:
 
-1. Ім’я має містити лише букви, цифри або символи `$` і `_`.
+1. Ім'я має містити лише букви, цифри або символи `$` і `_`.
 2. Перший символ не має бути числом.
 
 Ось приклади допустимих імен:
@@ -265,7 +265,7 @@ myBirthday = '01.01.2001'; // помилка, не можна перевизна
 
 ### Константи в верхньому регістрі
 
-Широко поширена практика використання констант як псевдонімів для значень, які важко запам’ятати і які відомі до початку виконання скрипта.
+Широко поширена практика використання констант як псевдонімів для значень, які важко запам'ятати і які відомі до початку виконання скрипта.
 
 Такі константи пишуться в верхньому регістрі з використанням підкреслень.
 
@@ -284,7 +284,7 @@ alert(color); // #FF7F00
 
 Переваги:
 
-- `COLOR_ORANGE` набагато легше запам’ятати, ніж `"#FF7F00"`.
+- `COLOR_ORANGE` набагато легше запам'ятати, ніж `"#FF7F00"`.
 - Набагато легше допустити помилку в `"#FF7F00"`, ніж під час введення `COLOR_ORANGE`.
 - Під час читання коду `COLOR_ORANGE` набагато зрозуміліше, ніж `#FF7F00`.
 
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 915763e77..bfd1109a2 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -12,7 +12,7 @@ let message = "привіт";
 message = 123456;
 ```
 
-Мови програмування, які дають змогу таке робити, називаються "динамічно типізованими". Мається на увазі, що типи даних визначені, але змінні не прив’язанні до жодного типу.
+Мови програмування, які дають змогу таке робити, називаються "динамічно типізованими". Мається на увазі, що типи даних визначені, але змінні не прив'язанні до жодного типу.
 
 ## Число (number)
 
@@ -68,7 +68,7 @@ n = 12.345;
 
 ## BigInt [#bigint-type]
 
-У JavaScript, тип "number" не може містити числа більші за <code>(2<sup>53</sup>-1)</code> (це `9007199254740991`), або менші за <code>-(2<sup>53</sup>-1)</code> для від’ємних чисел.
+У JavaScript, тип "number" не може містити числа більші за <code>(2<sup>53</sup>-1)</code> (це `9007199254740991`), або менші за <code>-(2<sup>53</sup>-1)</code> для від'ємних чисел.
 
 Якщо бути дійсно точним, тип "number" може зберігати більші цілі числа (до <code>1,7976931348623157 * 10<sup>308</sup></code>), але поза межами безпечного діапазону цілих чисел <code>±(2 <sup>53</sup>-1)</code> виникне помилка точності, оскільки не всі цифри вміщуються у фіксованому 64-бітному сховищі. Тому може бути збережено "приблизне" значення.
 
@@ -155,7 +155,7 @@ alert("результат: ${1 + 2}"); // результат: ${1 + 2} (подв
 Наприклад:
 
 ```js
-let nameFieldChecked = true; // так, ім’я було перевірене
+let nameFieldChecked = true; // так, ім'я було перевірене
 let ageFieldChecked = false; // ні, вік не був перевіреним
 ```
 
@@ -179,7 +179,7 @@ alert(isGreater); // true (результат порівняння — "так")
 let age = null;
 ```
 
-В JavaScript `null` не є "посиланням на неіснуючий об’єкт" або "покажчиком на null", як може бути в інших мовах програмування.
+В JavaScript `null` не є "посиланням на неіснуючий об'єкт" або "покажчиком на null", як може бути в інших мовах програмування.
 
 Це лише спеціальне значення, яке представляє "нічого", "порожнє" або "невідоме значення".
 
@@ -212,15 +212,15 @@ alert(age); // "undefined"
 
 ...Але ми не рекомендуємо так робити. Як правило, ми використовуємо `null`, щоби присвоїти змінній значення "порожнє" або "невідоме", тоді як `undefined` зарезервоване для позначення початкового значення для неприсвоєних речей.
 
-## Об’єкти (object) та символи (symbol)
+## Об'єкти (object) та символи (symbol)
 
 Тип `object` є особливим типом.
 
-Усі інші типи називаються "примітивами", тому що їхні значення можуть містити тільки один елемент (це може бути рядок, число, або будь-що інше). В об’єктах же зберігаються колекції даних і більш складні структури.
+Усі інші типи називаються "примітивами", тому що їхні значення можуть містити тільки один елемент (це може бути рядок, число, або будь-що інше). В об'єктах же зберігаються колекції даних і більш складні структури.
 
-Об’єкти є важливою частиною мови, тому ми окремо розглянемо їх у розділі <info:object> після того, як дізнаємося більше про примітиви.
+Об'єкти є важливою частиною мови, тому ми окремо розглянемо їх у розділі <info:object> після того, як дізнаємося більше про примітиви.
 
-Тип `symbol` використовується для створення унікальних ідентифікаторів в об’єктах. Ми згадали цей тип для повноти, проте докладніше вивчимо його після об’єктів.
+Тип `symbol` використовується для створення унікальних ідентифікаторів в об'єктах. Ми згадали цей тип для повноти, проте докладніше вивчимо його після об'єктів.
 
 ## Оператор typeof [#type-typeof]
 
@@ -256,9 +256,9 @@ typeof alert // "function"  (3)
 
 Останні три рядки можуть потребувати додаткового пояснення:
 
-1. `Math` — це вбудований об’єкт, який забезпечує математичні операції. Ми вивчимо його в розділі <info:number>. Тут він використаний лише як приклад об’єкта.
-2. Результатом `typeof null` є `"object"`. Це офіційно визнана помилка поведінки `typeof`, що є ще з ранніх днів JavaScript і зберігається для сумісності. Безперечно, `null` не є об’єктом. Це особливе значення з власним типом. У цьому разі поведінка `typeof` некоректна.
-3. Результатом `typeof alert` є `"function"`, тому що `alert` — це функція. Ми будемо вивчати функції в наступних розділах, де ми також побачимо, що в JavaScript немає спеціального типу "function". Функції належать до типу "об’єкт". Але `typeof` трактує їх по-іншому, повертаючи `"function"`. Це також присутнє з ранніх днів JavaScript. Технічно, така поведінка не зовсім правильна, але може бути зручною на практиці.
+1. `Math` — це вбудований об'єкт, який забезпечує математичні операції. Ми вивчимо його в розділі <info:number>. Тут він використаний лише як приклад об'єкта.
+2. Результатом `typeof null` є `"object"`. Це офіційно визнана помилка поведінки `typeof`, що є ще з ранніх днів JavaScript і зберігається для сумісності. Безперечно, `null` не є об'єктом. Це особливе значення з власним типом. У цьому разі поведінка `typeof` некоректна.
+3. Результатом `typeof alert` є `"function"`, тому що `alert` — це функція. Ми будемо вивчати функції в наступних розділах, де ми також побачимо, що в JavaScript немає спеціального типу "function". Функції належать до типу "об'єкт". Але `typeof` трактує їх по-іншому, повертаючи `"function"`. Це також присутнє з ранніх днів JavaScript. Технічно, така поведінка не зовсім правильна, але може бути зручною на практиці.
 
 ```smart header="Синтаксис `typeof(x)`"
 Можливо ви зустрічали інший синтаксис: `typeof(x)`. Це те саме, що `typeof x`.
@@ -290,6 +290,6 @@ typeof alert // "function"  (3)
 
 - Зазвичай використовують синтаксис `typeof x`, проте `typeof(x)` також можливий.
 - Повертає рядок із назвою типу, як-от `"string"`.
-- Для `null` повертає `"object"` —- це помилка в мові, `null` насправді не об’єкт.
+- Для `null` повертає `"object"` —- це помилка в мові, `null` насправді не об'єкт.
 
-У наступних розділах ми зосередимося на примітивних значеннях, а коли ознайомимося з ними, то перейдемо до об’єктів.
+У наступних розділах ми зосередимося на примітивних значеннях, а коли ознайомимося з ними, то перейдемо до об'єктів.
diff --git a/1-js/02-first-steps/06-alert-prompt-confirm/article.md b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
index dfd9377cb..b8fbafb24 100644
--- a/1-js/02-first-steps/06-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
@@ -97,7 +97,7 @@ alert( isBoss ); // true, якщо натиснута OK
 
 Усі ці методи є модальними: вони призупиняють виконання скриптів та не дають відвідувачам змогу взаємодіяти з рештою сторінки, поки вікно не буде закрите.
 
-Є два обмеження, пов’язані з усіма методами вище:
+Є два обмеження, пов'язані з усіма методами вище:
 
 1. Точне розташування модального вікна визначається браузером. Зазвичай це в центрі.
 2. Точний вигляд вікна також залежить від браузера. Ми не можемо його змінити.
diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md
index 324413407..2b0f8e526 100644
--- a/1-js/02-first-steps/07-type-conversions/article.md
+++ b/1-js/02-first-steps/07-type-conversions/article.md
@@ -6,10 +6,10 @@
 
 Є також випадки, коли нам необхідно явно перетворити значення на очікуваний тип.
 
-```smart header="Поки що не говоримо про об’єкти"
-У цьому розділі ми не будемо охоплювати об’єкти. Поки що ми поговоримо тільки про примітиви.
+```smart header="Поки що не говоримо про об'єкти"
+У цьому розділі ми не будемо охоплювати об'єкти. Поки що ми поговоримо тільки про примітиви.
 
-Пізніше, після ознайомлення з об’єктами, ми розглянемо їхнє перетворення в розділі <info:object-toprimitive>.
+Пізніше, після ознайомлення з об'єктами, ми розглянемо їхнє перетворення в розділі <info:object-toprimitive>.
 ```
 
 ## Перетворення на рядок
@@ -142,7 +142,7 @@ alert( Boolean(" ") ); // пробіли, також true (будь-які не
 |будь-які інші значення| `true` |
 
 
-Більшість із цих правил легко зрозуміти й запам’ятати. Примітними винятками, де люди зазвичай роблять помилки, є:
+Більшість із цих правил легко зрозуміти й запам'ятати. Примітними винятками, де люди зазвичай роблять помилки, є:
 
 - `undefined` є `NaN` як число, а не `0`.
 - `"0"` і рядки, що мають тільки пробіли, такі як `"   "`, є `true` як булеві значення.
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index f24baf220..6afecf7d7 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -43,7 +43,7 @@ JavaScript підтримує такі математичні операції:
 
 ### Остача від ділення %
 
-Оператор остачі `%`, попри свій зовнішній вигляд, не пов’язаний із відсотками.
+Оператор остачі `%`, попри свій зовнішній вигляд, не пов'язаний із відсотками.
 
 Результатом `a % b` є [остача](https://uk.wikipedia.org/wiki/Остача) цілочислового ділення `a` на `b`.
 
@@ -79,13 +79,13 @@ alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що к
 ```
 
 
-## Об’єднання рядків через бінарний +
+## Об'єднання рядків через бінарний +
 
 Розглянемо особливості операторів JavaScript, які виходять за межі шкільної арифметики.
 
 Зазвичай оператор плюс `+` додає числа.
 
-Але якщо бінарний `+` застосовується до рядків, він об’єднує їх:
+Але якщо бінарний `+` застосовується до рядків, він об'єднує їх:
 
 ```js
 let s = 'мій_' + 'рядок';
@@ -109,7 +109,7 @@ alert( 2 + '1' ); // "21"
 alert(2 + 2 + '1' ); // "41", а не "221"
 ```
 
-Тут оператори виконуються один за одним. Перший `+` додає два числа, тому він поверне `4`; а наступний оператор `+` вже додасть (об’єднає) попередній результат із рядком `1`. У підсумку ми отримаємо рядок `'41'` (`4 + '1'`).
+Тут оператори виконуються один за одним. Перший `+` додає два числа, тому він поверне `4`; а наступний оператор `+` вже додасть (об'єднає) попередній результат із рядком `1`. У підсумку ми отримаємо рядок `'41'` (`4 + '1'`).
 
 ```js run
 alert('1' + 2 + 2); // "122", а не "14"
@@ -158,7 +158,7 @@ alert( +"" );   // 0
 let apples = "2";
 let oranges = "3";
 
-alert( apples + oranges ); // "23", бінарний плюс об’єднує рядки
+alert( apples + oranges ); // "23", бінарний плюс об'єднує рядки
 ```
 
 Якщо ми хочемо використовувати їх як числа, нам потрібно конвертувати, а потім підсумувати їх:
@@ -178,7 +178,7 @@ alert( +apples + +oranges ); // 5
 
 З погляду математика надмірні плюси можуть здатися дивними. Але з погляду програміста тут немає нічого особливого: спочатку застосовуються унарні плюси, вони перетворюють рядки на числа, а потім бінарний плюс підсумовує їх.
 
-Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побачимо далі, це пов’язано з їхнім *вищим пріоритетом*.
+Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побачимо далі, це пов'язано з їхнім *вищим пріоритетом*.
 
 ## Пріоритет оператора
 
@@ -190,9 +190,9 @@ alert( +apples + +oranges ); // 5
 
 У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер пріоритету. Якщо пріоритет є однаковим, порядок виконання — зліва направо.
 
-Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (вам не потрібно її запам’ятовувати, але зверніть увагу, що унарні оператори мають вищий пріоритет за відповідні бінарні):
+Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (вам не потрібно її запам'ятовувати, але зверніть увагу, що унарні оператори мають вищий пріоритет за відповідні бінарні):
 
-| Пріоритет | Ім’я | Знак |
+| Пріоритет | Ім'я | Знак |
 |------------|------|------|
 | ... | ... | ... |
 | 14 | унарний плюс | `+` |
diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
index 9032c192f..5107c973c 100644
--- a/1-js/02-first-steps/09-comparison/article.md
+++ b/1-js/02-first-steps/09-comparison/article.md
@@ -202,7 +202,7 @@ alert( undefined == 0 ); // false (3)
 
 ### Як уникати проблем
 
-Чому ми переглядали ці приклади? Чи повинні ми постійно пам’ятати про всі ці особливості? Не обов’язково. З часом всі ці заплутані правила стануть для вас знайомими, але можна уникнути проблем, якщо дотримуватися надійних правил:
+Чому ми переглядали ці приклади? Чи повинні ми постійно пам'ятати про всі ці особливості? Не обов'язково. З часом всі ці заплутані правила стануть для вас знайомими, але можна уникнути проблем, якщо дотримуватися надійних правил:
 
 - Будьте пильні під час порівняння будь-якого значення з `undefined/null`, за винятком строгого порівняння `===`.
 - Не використовуйте порівняння `>= > < <=` зі змінними, які можуть приймати значення `null/undefined`, хіба що ви цілком впевнені в тому, що робите. Якщо змінна може приймати ці значення, то додайте для них окремі перевірки.
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 2f8c85628..ec91e5a5a 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -68,7 +68,7 @@ if (condition) {
 
 ## Блок "else"
 
-Вираз `if` може містити необов’язковий блок `else` ("інакше"). Він виконується, коли умова є хибною.
+Вираз `if` може містити необов'язковий блок `else` ("інакше"). Він виконується, коли умова є хибною.
 
 Наприклад:
 ```js run
@@ -101,7 +101,7 @@ if (year < 2015) {
 
 У наведеному вище коді JavaScript спочатку перевіряє `year < 2015`. Якщо це не вірно, перевіряється наступна умова `year > 2015`. Якщо це також неправда, показується останній `alert`.
 
-Може бути більше `else if` блоків. Останній блок `else` є необов’язковим.
+Може бути більше `else if` блоків. Останній блок `else` є необов'язковим.
 
 ## Умовний оператор '?'
 
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 968267399..a90d30249 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,6 +1,6 @@
 # Логічні оператори
 
-В JavaScript існує чотири логічні оператори: `||` (АБО), `&&` (І), `!` (НЕ), `??` (оператор null-об’єднання). В цьому розділі ми розглянемо перші три оператори, а оператор `??` — в наступному розділі.
+В JavaScript існує чотири логічні оператори: `||` (АБО), `&&` (І), `!` (НЕ), `??` (оператор null-об'єднання). В цьому розділі ми розглянемо перші три оператори, а оператор `??` — в наступному розділі.
 
 Хоча вони називаються "логічними", вони можуть бути застосовані до значень будь-якого типу, не тільки булевих. Їх результати також можуть бути будь-якого типу.
 
@@ -101,7 +101,7 @@ alert( undefined || null || 0 ); // 0 (усі хибні, повертаєтьс
 
 1. **Отримання першого істинного значення зі списку змінних або виразів.**
 
-    Наприклад, маємо змінні `firstName`, `lastName` та `nickName`, усі необов’язкові (тобто вони можуть бути невизначеними або мати хибні значення).
+    Наприклад, маємо змінні `firstName`, `lastName` та `nickName`, усі необов'язкові (тобто вони можуть бути невизначеними або мати хибні значення).
 
     Використаємо АБО `||`, щоб вибрати ту змінну, яка має дані, і виведемо її (або рядок `"Анонім"`, якщо жодна змінна не має даних):
 
@@ -175,7 +175,7 @@ if (1 && 0) { // обчислюється як true && false
 
 ## І "&&" шукає перше хибне значення
 
-Дано декілька значень, об’єднаних кількома І:
+Дано декілька значень, об'єднаних кількома І:
 
 ```js
 result = value1 && value2 && value3;
diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
index 1f8157ed6..53e7c7582 100644
--- a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
+++ b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -1,8 +1,8 @@
-# Оператор об’єднання з null '??'
+# Оператор об'єднання з null '??'
 
 [recent browser="new"]
 
-Оператор об’єднання з null записується як два знаки питання `??`.
+Оператор об'єднання з null записується як два знаки питання `??`.
 
 Оскільки `null` і `undefined` сприймаються однаково, ми введемо спеціальну домовленність. В цій статті ми будемо вважати, що значення виразу "визначене", якщо воно відрізняється від `null` та `undefined`.
 
@@ -12,7 +12,7 @@
 
 Інакше кажучи, `??` повертає перший аргумент, якщо він не `null/undefined`. Інакше, другий.
 
-Оператор об’єднання з null не є абсолютно новим. Це просто хороший синтаксис, щоб отримати перше "визначене" значення з двох.
+Оператор об'єднання з null не є абсолютно новим. Це просто хороший синтаксис, щоб отримати перше "визначене" значення з двох.
 
 Ми можемо переписати вираз `result = a ?? b`, використовуючи оператори, які ми вже знаємо:
 
@@ -26,7 +26,7 @@ result = (a !== null && a !== undefined) ? a : b;
 Наприклад, тут ми показуємо значення у змінній `user`, якщо її значення не `null/undefined`, інакше -- показуємо `Анонімний`:
 
 
-Ось приклад з `user`, якому не присвоєне ім’я:
+Ось приклад з `user`, якому не присвоєне ім'я:
 
 ```js run
 let user;
@@ -38,7 +38,7 @@ alert(user ?? "Анонімний"); // Анонімний (user є undefined)
 
 Скажімо, у нас є дані користувача в змінних `firstName`, `lastName` або `nickName`. Всі вони можуть бути не визначені, якщо користувач вирішив не вводити значення.
 
-Ми хотіли б показати ім’я користувача, використовуючи одну з цих змінних, або показати "Анонімний", якщо всі вони `null/undefined`.
+Ми хотіли б показати ім'я користувача, використовуючи одну з цих змінних, або показати "Анонімний", якщо всі вони `null/undefined`.
 
 Використаймо оператор `??` для цього:
 
@@ -72,7 +72,7 @@ alert(firstName || lastName || nickName || "Анонімний"); // Супер
 
 Історично, оператор АБО `||` був першим. Він існує з початку JavaScript, тому розробники використовували його для цих цілей протягом тривалого часу.
 
-З іншого боку, оператор об’єднання з null `??` було нещодавно додано в JavaScript, і причиною того було те, що люди були не дуже задоволені `||`.
+З іншого боку, оператор об'єднання з null `??` було нещодавно додано в JavaScript, і причиною того було те, що люди були не дуже задоволені `||`.
 
 Важлива різниця між ними полягає в тому, що:
 - `||` повертає перше *істинне* значення.
@@ -102,7 +102,7 @@ alert(height ?? 100); // 0
 
 Пріоритет оператора `??` такий самий, як у `||`. Він дорівнює `3` у [таблиці MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
-Це означає, що, як і `||`, оператор об’єднання з null `??` оцінюється до `=` та `?`, але після більшості інших операцій, таких як `+`, `*`.
+Це означає, що, як і `||`, оператор об'єднання з null `??` оцінюється до `=` та `?`, але після більшості інших операцій, таких як `+`, `*`.
 
 ``` js
 let height = null;
@@ -148,7 +148,7 @@ alert(x); // 2
 
 ## Підсумки
 
-- Оператор об’єднання з null `??` надає короткий спосіб вибору першого "визначеного" значення зі списку.
+- Оператор об'єднання з null `??` надає короткий спосіб вибору першого "визначеного" значення зі списку.
 
     Він використовується для присвоєння типових значень до змінних:
 
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
index e0c195fa8..b2b9cc338 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
@@ -8,6 +8,6 @@ importance: 5
 
 Цикл повинен запитувати число доти, доки відвідувач не введе число, більше за `100`, або не скасує ввід/введе порожній рядок.
 
-Ми припускаємо, що відвідувач вводитиме лише числа. В цьому завданні не обов’язково реалізовувати оброблення не-числового введення.
+Ми припускаємо, що відвідувач вводитиме лише числа. В цьому завданні не обов'язково реалізовувати оброблення не-числового введення.
 
 [demo]
diff --git a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
index 4d3cf8423..a911d0733 100644
--- a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
+++ b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
@@ -14,4 +14,4 @@ function checkAge(age) {
 }
 ```
 
-Зверніть увагу, що круглі дужки навколо `age > 18` не обов’язкові. Вони тут для кращої читабельності коду.
+Зверніть увагу, що круглі дужки навколо `age > 18` не обов'язкові. Вони тут для кращої читабельності коду.
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index d4c3147ff..b9bdfcc92 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -20,7 +20,7 @@ function showMessage() {
 }
 ```
 
-Спочатку ми пишемо `function` — це ключове слово (keyword), яке дає зрозуміти комп’ютеру, що далі буде оголошення функції. Потім — *назву функції* і список її *параметрів* в дужках (розділені комою). Якщо параметрів немає, ми залишаємо *пусті дужки*. І нарешті, код функції, який також називають *тілом функції* між фігурними дужками.
+Спочатку ми пишемо `function` — це ключове слово (keyword), яке дає зрозуміти комп'ютеру, що далі буде оголошення функції. Потім — *назву функції* і список її *параметрів* в дужках (розділені комою). Якщо параметрів немає, ми залишаємо *пусті дужки*. І нарешті, код функції, який також називають *тілом функції* між фігурними дужками.
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
@@ -28,7 +28,7 @@ function name(parameter1, parameter2, ... parameterN) {
 }
 ```
 
-Нашу нову функцію можна викликати, написавши її ім’я і дужки: `showMessage()`.
+Нашу нову функцію можна викликати, написавши її ім'я і дужки: `showMessage()`.
 
 Наприклад:
 
@@ -107,7 +107,7 @@ alert( userName ); // *!*Богдан*/!*, значення було зміне
 
 Зовнішня змінна використовується тоді, коли немає локальної.
 
-Якщо всередині функції є змінна з таким самим ім’ям, то вона *перекриває* зовнішню. Наприклад, наступний код використовує локальну змінну `userName`. Зовнішня ігнорується.
+Якщо всередині функції є змінна з таким самим ім'ям, то вона *перекриває* зовнішню. Наприклад, наступний код використовує локальну змінну `userName`. Зовнішня ігнорується.
 
 ```js run
 let userName = 'Іван'; // оголошення зовнішньої змінної
@@ -418,9 +418,9 @@ return (
 
 ## Найменування функції [#function-naming]
 
-Функції виконують дії. Тому в їхніх іменах зазвичай використовують дієслова. Ім’я повинне бути лаконічним, повинне якнайточніше описувати, що робить функція, щоб кожен хто читає код зміг зрозуміти, що саме робить функція.
+Функції виконують дії. Тому в їхніх іменах зазвичай використовують дієслова. Ім'я повинне бути лаконічним, повинне якнайточніше описувати, що робить функція, щоб кожен хто читає код зміг зрозуміти, що саме робить функція.
 
-Поширена практика розпочинати ім’я функції зі словесного префіксу, який описує дію. В команді має бути домовленість щодо значення префіксів.
+Поширена практика розпочинати ім'я функції зі словесного префіксу, який описує дію. В команді має бути домовленість щодо значення префіксів.
 
 Наприклад, функції, які починаються з префіксу `"show"` зазвичай щось показують.
 
@@ -441,7 +441,7 @@ createForm(..)      // створює форму (і зазвичай її по
 checkPermission(..) // перевіряє доступ, повертає true/false
 ```
 
-Якщо є префікси, погляд на ім’я функції дає зрозуміти, яку роботу вона виконує і яке значення повертає.
+Якщо є префікси, погляд на ім'я функції дає зрозуміти, яку роботу вона виконує і яке значення повертає.
 
 ```smart header="Одна функція -- одна дія"
 Функція повинна робити саме те, що написано в її імені, не більше.
@@ -517,7 +517,7 @@ function isPrime(n) {
 Оголошення функції виглядає ось так:
 
 ```js
-function ім’я(параметри, розділені, комою) {
+function ім'я(параметри, розділені, комою) {
   /* тіло, код функції */
 }
 ```
@@ -532,8 +532,8 @@ function ім’я(параметри, розділені, комою) {
 
 Найменування функцій:
 
-- Ім’я функції повинне бути коротким і чітко відображати, що робить функція. Побачивши виклик функції в коді, ви повинні зразу зрозуміти, що функція робить, і що повертає.
-- Функція -- це дія, тому її ім’я зазвичай складається з дієслова.
+- Ім'я функції повинне бути коротким і чітко відображати, що робить функція. Побачивши виклик функції в коді, ви повинні зразу зрозуміти, що функція робить, і що повертає.
+- Функція -- це дія, тому її ім'я зазвичай складається з дієслова.
 - Є багато загальноприйнятих префіксів, такі як `create…`, `show…`, `get…`, `check…` тощо. Використовуйте їх щоб пояснити, що робить функція.
 
 Функції -- це основні будівельні блоки скриптів. Ми розглянули лише основи функцій в JavaScript, проте вже зараз цього достатньо, щоб почати їх створювати і використовувати. Це лише початок шляху. Ми будемо неодноразово повертатися до функцій і вивчатимо їх все глибше і глибше.
diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md
index 4769e58e1..12a2d8b09 100644
--- a/1-js/02-first-steps/18-javascript-specials/article.md
+++ b/1-js/02-first-steps/18-javascript-specials/article.md
@@ -31,7 +31,7 @@ alert("Після цього повідомлення буде помилка")
 
 ```js
 function f() {
-  // після оголошення функції не обов’язково ставити крапку з комою
+  // після оголошення функції не обов'язково ставити крапку з комою
 }
 
 for(;;) {
@@ -69,7 +69,7 @@ for(;;) {
 - `const` (константа, не можна змінювати)
 - `var` (старий спосіб, ми переглянемо його пізніше)
 
-Ім’я змінної може включати:
+Ім'я змінної може включати:
 - Літери і цифри; першим символом має бути лише літера, не цифра.
 - Допускаються символи `$` та `_`, в парі з літерами.
 - Не латинські символи, як кирилиця та ієрогліфи також допускаються, але вони не мають широкого вжитку.
@@ -89,7 +89,7 @@ x = "Іван"; // тип змінився на "рядок"
 - булевий тип (`boolean`) для логічних значень: `true/false`,
 - `null` — тип з єдиним значенням `null`, який означає "пусто" або "не існує",
 - `undefined` — тип з єдиним значенням `undefined`, який означає "не присвоєно",
-- об’єкт (`object`) та символ (`symbol`) — для складних структур даних та унікальних ідентифікаторів, ми їх ще не вивчили.
+- об'єкт (`object`) та символ (`symbol`) — для складних структур даних та унікальних ідентифікаторів, ми їх ще не вивчили.
 
 Оператор `typeof` повертає тип змінної, за винятком двох випадків:
 ```js
@@ -117,7 +117,7 @@ typeof function(){} == "function" // спеціально для функцій
 Наприклад:
 
 ```js run
-let userName = prompt("Ваше ім’я?", "Настя");
+let userName = prompt("Ваше ім'я?", "Настя");
 let isBunWanted = confirm("Хочете булочку?");
 
 alert( "Відвідувач: " + userName ); // Настя
@@ -133,7 +133,7 @@ JavaScript підтримує такі оператори:
 Арифметичні
 : Звичайні: `* + - /`, а також оператори `%`, для визначення остачі від ділення та `**` для піднесення до степеня.
 
-    Бінарний плюс `+` об’єднує (конкатинує) рядки. А якщо одним із операндів буде рядок, то інший операнд також буде конвертовано в рядок:
+    Бінарний плюс `+` об'єднує (конкатинує) рядки. А якщо одним із операндів буде рядок, то інший операнд також буде конвертовано в рядок:
 
     ```js run
     alert( '1' + 2 ); // '12', рядок
@@ -150,9 +150,9 @@ JavaScript підтримує такі оператори:
 : Єдиний оператор з трьома параметрами: `cond ? resultA : resultB`. Якщо `cond` вірно, повертається `resultA`, інакше – `resultB`.
 
 Логічні оператори
-: Логічні І `&&` та АБО `||` використовують так звані "ледачі обчислення" і насамкінець повертають значення, на якому воно зупинилося (не обов’язково `true` або `false`). Логічне НЕ `!` конвертує операнд в логічний тип і повертає інвертоване значення.
+: Логічні І `&&` та АБО `||` використовують так звані "ледачі обчислення" і насамкінець повертають значення, на якому воно зупинилося (не обов'язково `true` або `false`). Логічне НЕ `!` конвертує операнд в логічний тип і повертає інвертоване значення.
 
-Оператор об’єднання з null
+Оператор об'єднання з null
 : Оператор `??` дає можливість вибору визначеного значення зі списку змінних. Результатом `a ?? b` буде `a` якщо його значення відмінне від `null/undefined`, інакше `b`.
 
 Порівнювання
@@ -202,7 +202,7 @@ JavaScript підтримує такі оператори:
 
 Детальніше: <info:while-for>.
 
-Пізніше ми вивчимо більше видів циклів, які працюють з об’єктами.
+Пізніше ми вивчимо більше видів циклів, які працюють з об'єктами.
 
 ## Конструкція "switch"
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index b61411861..a7cf78377 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -127,7 +127,7 @@ function hello(name) {
 
     ![](chrome-sources-debugger-trace-1.svg)
 
-    Виконання коду відновилося, дійшло до іншої точки зупинки, всередині `say()` і налагоджувач знову (тимчасово) зупинив виконання. Зверніть увагу на вкладку "Call Stack" праворуч: в списку з’явився ще один виклик. Ми тепер всередині функції `say()`.
+    Виконання коду відновилося, дійшло до іншої точки зупинки, всередині `say()` і налагоджувач знову (тимчасово) зупинив виконання. Зверніть увагу на вкладку "Call Stack" праворуч: в списку з'явився ще один виклик. Ми тепер всередині функції `say()`.
 
 <span class="devtools" style="background-position:-200px -190px"></span>&ensp;—&ensp;"Step": виконати наступну команду. Швидка клавіша: `key:F9`.
 : Якщо ми натиснемо на неї – виконається функція `alert`.
diff --git a/1-js/03-code-quality/04-ninja-code/article.md b/1-js/03-code-quality/04-ninja-code/article.md
index eec5e67ce..479e100da 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -40,7 +40,7 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
 ```quote author="Лао-цзи (Дао де цзін)"
 Дао безсловесне.
-Ім’я, яке можна назвати, не є постійним ім’ям.
+Ім'я, яке можна назвати, не є постійним ім'ям.
 ```
 
 Ще один спосіб писати стислий код -- використовувати однолітерні змінні. Наприклад: `a`, `b` або `c`.
@@ -73,19 +73,19 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 Великий образ неозорий.
 ```
 
-Обираючи ім’я, намагайтесь використовувати найбільш абстрактне слово. Прикладом може бути `obj`, `data`, `value`, `item`, `elem` тощо.
+Обираючи ім'я, намагайтесь використовувати найбільш абстрактне слово. Прикладом може бути `obj`, `data`, `value`, `item`, `elem` тощо.
 
 - **`data` є ідеальним варіантом для імені змінної.** Використовуйте його всюди, де можете. І справді, кожна змінна має *дані*, вірно?
 
-    А що робити, якщо ім’я `data` вже зайняте? Спробуйте `value` -- воно також універсальне. Врешті-решт, кожна змінна набуває якесь *значення*.
+    А що робити, якщо ім'я `data` вже зайняте? Спробуйте `value` -- воно також універсальне. Врешті-решт, кожна змінна набуває якесь *значення*.
 
-- **Добирайте ім’я змінним згідно з їхнім типом: `str`, `num`...**
+- **Добирайте ім'я змінним згідно з їхнім типом: `str`, `num`...**
 
     Спробуйте. Той, що щойно став на шлях ніндзя, може засумніватися чи дійсно такі імена корисні. Авжеж!
 
-    Так, ім’я змінної дещо означає. Це допомагає зрозуміти, що ми використовуємо: рядок, число, чи щось ще. Проте коли сторонні люди намагатимуться зрозуміти код, вони будуть здивовані, що інформація про те, що саме містить змінна, відсутня. У результаті вони не зможуть змінити ваш добре обміркований код.
+    Так, ім'я змінної дещо означає. Це допомагає зрозуміти, що ми використовуємо: рядок, число, чи щось ще. Проте коли сторонні люди намагатимуться зрозуміти код, вони будуть здивовані, що інформація про те, що саме містить змінна, відсутня. У результаті вони не зможуть змінити ваш добре обміркований код.
 
-    Тип змінної досить легко знайти під час налаштування. Але що означає її ім’я? Який саме рядок/число вона зберігає?
+    Тип змінної досить легко знайти під час налаштування. Але що означає її ім'я? Який саме рядок/число вона зберігає?
 
     Жодного шансу дізнатися про це без тривалої медитації!
 
@@ -105,12 +105,12 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 ## Хитромудрі синоніми
 
 ```quote author="Лао-цзи (Дао де цзін)"
-Істина, яка може бути виражена словами, не є правдива істина. Ім’я, яке може бути названо, не є правдиве ім’я.
+Істина, яка може бути виражена словами, не є правдива істина. Ім'я, яке може бути названо, не є правдиве ім'я.
 ```
 
 Використання *схожих* імен для *однакових* речей зробить життя цікавішим і продемонструє рівень вашої креативності.
 
-Наприклад, розглянемо префікси функцій. Якщо функція виводить повідомлення на екран -- почніть її ім’я з `display…`, як то `displayMessage`. А для іншої функції, що показуватиме на екрані ще щось (скажімо, ім’я користувача), почніть ім’я з `show…` (наприклад, `showName`).
+Наприклад, розглянемо префікси функцій. Якщо функція виводить повідомлення на екран -- почніть її ім'я з `display…`, як то `displayMessage`. А для іншої функції, що показуватиме на екрані ще щось (скажімо, ім'я користувача), почніть ім'я з `show…` (наприклад, `showName`).
 
 Натякніть, що є деяка тонка відмінність між цими функціями, хоча насправді її немає.
 
@@ -126,7 +126,7 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
 ```quote author="Лао-цзи (Дао де цзін)"
 При встановленні порядку<br>
-з’явилися імена.<br>
+з'явилися імена.<br>
 Оскільки виникли імена,<br>
 потрібно знати межу їх використання.
 ```
@@ -137,7 +137,7 @@ i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 
 У функції намагайтесь використовувати лише змінні, що були передані як параметри.
 
-Це суттєво ускладнить розуміння того, що саме міститься в змінній *зараз*, і звідки воно там узялося. Метою цих дій є розвиток інтуїції та пам’яті людини, котра читає ваш код. Людина зі слабкою інтуїцією аналізуватиме такий код рядок за рядком і слідкуватиме за змінами в кожному блоці коду.
+Це суттєво ускладнить розуміння того, що саме міститься в змінній *зараз*, і звідки воно там узялося. Метою цих дій є розвиток інтуїції та пам'яті людини, котра читає ваш код. Людина зі слабкою інтуїцією аналізуватиме такий код рядок за рядком і слідкуватиме за змінами в кожному блоці коду.
 
 **Просунутим варіантом такого підходу є непомітна (!) заміна значення змінної на щось дуже схоже всередині циклу або функції.**
 
@@ -161,13 +161,13 @@ function ninjaFunction(elem) {
 
 Ставте підкреслення `_` та `__` перед іменами змінних. Наприклад, `_name` або `__value`. Краще буде, якщо тільки ви будете розуміти їхнє значення. А ще краще, щоб ніякого значення не було зовсім, додавайте їх задля розваги. Або використовуйте різні значення в різних місцях.
 
-Ви вбиваєте двох зайців одним сюрикеном. По-перше, код стає довшим і менш зрозумілим, і, по-друге, колега-програміст зможе витратити багато часу з’ясовуючи сакральне значення вашого підкреслення.
+Ви вбиваєте двох зайців одним сюрикеном. По-перше, код стає довшим і менш зрозумілим, і, по-друге, колега-програміст зможе витратити багато часу з'ясовуючи сакральне значення вашого підкреслення.
 
 Проворний ніндзя використовує підкреслення в одній частині коду й уникає їх в іншій. Це робить код ще більш вразливим і підвищує можливість виникнення помилок у майбутньому.
 
 ## Покажіть свою любов
 
-Нехай усі бачать, наскільки величні ваші сутності! Читач обов’язково зрадіє таким іменам, як `superElement`, `megaFrame` та `niceItem`.
+Нехай усі бачать, наскільки величні ваші сутності! Читач обов'язково зрадіє таким іменам, як `superElement`, `megaFrame` та `niceItem`.
 
 Справді, з одного боку, дещо все ж таки написано: `super..`, `mega..`, `nice..`. Але, з іншого боку -- це не пояснює нічого. Той, хто читатиме ваш код, витратить не одну годину свого оплаченого робочого часу на медитацію і пошуки прихованого значення цих слів.
 
@@ -205,11 +205,11 @@ function render() {
 
 **Дійсно гарним прийомом є додавати "корисну" дію до них, окрім їхньої основної задачі.**
 
-Вираз приголомшеного подиву на обличчі вашого колеги, коли він побачить, що функція з ім’ям `is..`, `check..` чи `find...` щось змінює, неодмінно розширить межі його свідомості.
+Вираз приголомшеного подиву на обличчі вашого колеги, коли він побачить, що функція з ім'ям `is..`, `check..` чи `find...` щось змінює, неодмінно розширить межі його свідомості.
 
 **Іншим способом здивувати є повернення нестандартного результату.**
 
-Покажіть своє оригінальне мислення! Нехай виклик функції `checkPermission` поверне не `true/false`, а складний об’єкт з результатом перевірки.
+Покажіть своє оригінальне мислення! Нехай виклик функції `checkPermission` поверне не `true/false`, а складний об'єкт з результатом перевірки.
 
 Програмісти, що намагатимуться написати `if (checkPermission(..))`, будуть дивуватись, чому воно не працює. Скажіть їм: "Вивчайте документацію!". І дайте їм почитати цю статтю.
 
@@ -221,7 +221,7 @@ function render() {
 Воно є і праворуч, і ліворуч.
 ```
 
-Не треба обмежувати алгоритм функції лише тим, що пов’язано з її ім’ям. Мисліть ширше.
+Не треба обмежувати алгоритм функції лише тим, що пов'язано з її ім'ям. Мисліть ширше.
 
 Наприклад, функція `validateEmail(email)` може (окрім перевірки адреси електронної пошти на відповідність правилам) показувати повідомлення про помилку та пропонувати ввести нову адресу.
 
diff --git a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
index 215f14e3e..3a0f00844 100644
--- a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
+++ b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
@@ -4,7 +4,7 @@
 
 Іноді простіше написати таким чином, але якщо трапляється помилка, стає не очевидно, що пішло не так.
 
-Якщо помилка трапляється посеред складного потоку виконання, то нам доведеться з’ясувати які були дані на той момент. Тобто, нам доведеться *налагоджувати тест*.
+Якщо помилка трапляється посеред складного потоку виконання, то нам доведеться з'ясувати які були дані на той момент. Тобто, нам доведеться *налагоджувати тест*.
 
 Було б набагато краще розбити тест на кілька блоків `it` із чітко прописаними вхідними даними та результатами.
 
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index efe815dfc..4a45d7e34 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -16,7 +16,7 @@
 
 Наприклад, ми створили функцію `f`. Перевірили деякий код, тестуємо: `f(1)` працює, але `f(2)` не працює. Ми підправляємо код і тепер `f(2)` працює. Здається, що справу зроблено? Але ми забули перевірити чи `f(1)` досі працює. Це може призвести до помилки.
 
-Це дуже типово. Коли ми щось розробляємо, ми пам’ятаємо про багато можливих випадків використання. Але не треба очікувати, що програміст перевірятиме їх усі вручну після кожної зміни. Так стає легко виправити щось одне і зламати інше.
+Це дуже типово. Коли ми щось розробляємо, ми пам'ятаємо про багато можливих випадків використання. Але не треба очікувати, що програміст перевірятиме їх усі вручну після кожної зміни. Так стає легко виправити щось одне і зламати інше.
 
 **Автоматизоване тестування означає, що тести пишуться окремо від основного коду, доповнюючи його. Вони запускають наші функції різними способами і порівнюють результати з очікуваними.**
 
@@ -96,7 +96,7 @@ describe("pow", function() {
 ```html src="index.html"
 ```
 
-Сторінку можна розділити на п’ять частин:
+Сторінку можна розділити на п'ять частин:
 
 1. `<head>` містить сторонні бібліотеки та стилі для тестів.
 2. `<script>` містить код функції, яку треба тестувати, в нашому випадку - код функції `pow`.
diff --git a/1-js/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md
index f92aa15af..b7a3dea1d 100644
--- a/1-js/03-code-quality/06-polyfills/article.md
+++ b/1-js/03-code-quality/06-polyfills/article.md
@@ -24,7 +24,7 @@
 
 [Транспілятор](https://uk.wikipedia.org/wiki/Транскомпілятор) -- це спеціальний інструмент, який «перекладає» вихідний код з однієї мови програмування в код на іншій мові програмування. Також обробка коду може виконуватися в межах однієї мови програмування. Транспілятор парсить  ("читає та розуміє") сучасний код і переписує його, використовуючи старі синтаксичні конструкції, які працюють на старих рушіях.
 
-Наприклад, JavaScript до 2020 року не мав "оператора об’єднання з null" `??`. Якщо відвідувач використовує старий браузер, він не зможе виконати код, на кшталт `height = height ?? 100`.
+Наприклад, JavaScript до 2020 року не мав "оператора об'єднання з null" `??`. Якщо відвідувач використовує старий браузер, він не зможе виконати код, на кшталт `height = height ?? 100`.
 
 Транспілятор проаналізує такий код і перепише `height ?? 100` на `(height !== undefined && height !== null) ? height : 100`.
 
@@ -38,7 +38,7 @@ height = (height !== undefined && height !== null) ? height : 100;
 
 Тепер, переписаний код буде коректно виконуватися на старих рушіях JavaScript.
 
-Зазвичай, розробник запускає на своєму комп’ютері транспілятор разом з компілятором, а вже після цього розгортає ("деплоє" від слова deploy) код на сервер.
+Зазвичай, розробник запускає на своєму комп'ютері транспілятор разом з компілятором, а вже після цього розгортає ("деплоє" від слова deploy) код на сервер.
 
 Говорячи про імена, [Babel](https://babeljs.io) -- один з найвідоміших транспіляторів.
 
diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md
index 720e5b95f..a843e77ff 100644
--- a/1-js/04-object-basics/01-object/2-hello-object/task.md
+++ b/1-js/04-object-basics/01-object/2-hello-object/task.md
@@ -6,9 +6,9 @@ importance: 5
 
 Напишіть код, виконавши завдання з кожного пункту окремим рядком:
 
-1. Створіть порожній об’єкт `user`.
+1. Створіть порожній об'єкт `user`.
 2. Додайте властивість `name` зі значенням `Іван`.
 3. Додайте властивість `surname` зі значенням `Сміт`.
 4. Змініть значення `name` на `Петро`.
-5. Видаліть властивість `name` з об’єкта.
+5. Видаліть властивість `name` з об'єкта.
 
diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md
index 739cf49c0..e3fe330f0 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/solution.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md
@@ -1 +1 @@
-Просто в циклі перебираємо властивості об’єкта і повертаємо `false`, як тільки зустрічаємо властивість.
\ No newline at end of file
+Просто в циклі перебираємо властивості об'єкта і повертаємо `false`, як тільки зустрічаємо властивість.
\ No newline at end of file
diff --git a/1-js/04-object-basics/01-object/3-is-empty/task.md b/1-js/04-object-basics/01-object/3-is-empty/task.md
index 015b7249f..5bcd592b2 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/task.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Перевірка на порожнечу
 
-Напишіть функцію `isEmpty(obj)`, яка повертає `true`, якщо об’єкт не має властивості, інакше `false`.
+Напишіть функцію `isEmpty(obj)`, яка повертає `true`, якщо об'єкт не має властивості, інакше `false`.
 
 Має так працювати:
 
diff --git a/1-js/04-object-basics/01-object/5-sum-object/task.md b/1-js/04-object-basics/01-object/5-sum-object/task.md
index c40290a71..2c1ee73f9 100644
--- a/1-js/04-object-basics/01-object/5-sum-object/task.md
+++ b/1-js/04-object-basics/01-object/5-sum-object/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Сума властивостей об’єкта
+# Сума властивостей об'єкта
 
-У нас є об’єкт для зберігання заробітної плати нашої команди:
+У нас є об'єкт для зберігання заробітної плати нашої команди:
 
 ```js
 let salaries = {
@@ -16,4 +16,4 @@ let salaries = {
 
 Напишіть код для підсумовування всіх зарплат і збережіть у змінній `sum`. У наведеному вище прикладі має бути `390`.
 
-Якщо об’єкт `salaries` порожній, то результат має бути `0`.
\ No newline at end of file
+Якщо об'єкт `salaries` порожній, то результат має бути `0`.
\ No newline at end of file
diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
index d39068130..8053dbf8f 100644
--- a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
+++ b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
@@ -4,7 +4,7 @@ importance: 3
 
 # Помножте числові значення властивостей на 2
 
-Створіть функцію `multiplyNumeric(obj)`, яка примножує всі числові властивості об’єкта `obj` на `2`.
+Створіть функцію `multiplyNumeric(obj)`, яка примножує всі числові властивості об'єкта `obj` на `2`.
 
 Наприклад:
 
@@ -26,7 +26,7 @@ menu = {
 };
 ```
 
-Зверніть увагу, що `multiplyNumeric` не потрібно нічого повертати. Слід безпосередньо змінювати об’єкт.
+Зверніть увагу, що `multiplyNumeric` не потрібно нічого повертати. Слід безпосередньо змінювати об'єкт.
 
 P.S. Використовуйте `typeof` для перевірки, що значення властивості числове.
 
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 1df967a6c..5372b4ee5 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -1,46 +1,46 @@
 
-# Об’єкти
+# Об'єкти
 
 Як ми знаємо з глави <info:types>, у JavaScript є вісім типів даних. Сім з них називаються "примітивними", оскільки їх значення містять лише одну річ (чи то рядок, число чи щось інше).
 
-На противагу цьому, об’єкти використовуються для зберігання ключів різних колекцій даних та складніших об’єктів. У JavaScript об’єкти проникають майже в усі аспекти мови. Тому ми повинні їх спочатку зрозуміти, перш ніж заглиблюватися в складніші теми.
+На противагу цьому, об'єкти використовуються для зберігання ключів різних колекцій даних та складніших об'єктів. У JavaScript об'єкти проникають майже в усі аспекти мови. Тому ми повинні їх спочатку зрозуміти, перш ніж заглиблюватися в складніші теми.
 
-Об’єкт можна створити за допомогою фігурних дужок `{…}` з необов’язковим списком *властивостей*. Властивість -- це пара "ключ: значення", де `ключ` -- це рядок (також називається "ім’я властивості"), а `значення` може бути будь-яким.
+Об'єкт можна створити за допомогою фігурних дужок `{…}` з необов'язковим списком *властивостей*. Властивість -- це пара "ключ: значення", де `ключ` -- це рядок (також називається "ім'я властивості"), а `значення` може бути будь-яким.
 
-Ми можемо уявити собі об’єкт як шафу з підписаними файлами. Кожен фрагмент даних зберігається у своєму файлі за допомогою ключа. Легко знайти файл за назвою або додати/видалити файл.
+Ми можемо уявити собі об'єкт як шафу з підписаними файлами. Кожен фрагмент даних зберігається у своєму файлі за допомогою ключа. Легко знайти файл за назвою або додати/видалити файл.
 
 ![](object.svg)
 
-Порожній об’єкт ("порожню шафу") можна створити за допомогою одного з двох синтаксисів:
+Порожній об'єкт ("порожню шафу") можна створити за допомогою одного з двох синтаксисів:
 
 ```js
-let user = new Object(); // синтаксис "конструктора об’єктів"
-let user = {};  // синтаксис "літералу об’єкта"
+let user = new Object(); // синтаксис "конструктора об'єктів"
+let user = {};  // синтаксис "літералу об'єкта"
 ```
 
 ![](object-user-empty.svg)
 
-Зазвичай використовуються фігурні дужки `{...}`. Таке оголошення називається *літералом об’єкта*.
+Зазвичай використовуються фігурні дужки `{...}`. Таке оголошення називається *літералом об'єкта*.
 
 ## Літерали та властивості
 
 Ми можемо одразу помістити деякі властивості у `{...}` як пари "ключ: значення":
 
 ```js
-let user = {     // об’єкт
+let user = {     // об'єкт
   name: "Іван",  // за ключем "name" зберігаємо значення "Іван"
   age: 30        // за ключем "age" зберігати значення "30" 
 };
 ```
 
-Властивість має ключ (також відомий як "ім’я" або "ідентифікатор") перед двокрапкою `":"` і значення праворуч від нього.
+Властивість має ключ (також відомий як "ім'я" або "ідентифікатор") перед двокрапкою `":"` і значення праворуч від нього.
 
-В об’єкті `user` зараз знаходяться дві властивості:
+В об'єкті `user` зараз знаходяться дві властивості:
 
-1. Перша властивість з ім’ям `"name"` і значенням `"Іван"`.
-2. Друга властивість з ім’ям `"age"` і значенням `30`.
+1. Перша властивість з ім'ям `"name"` і значенням `"Іван"`.
+2. Друга властивість з ім'ям `"age"` і значенням `30`.
 
-Отриманий об’єкт `user` можна уявити собі як шафу з двома підписаними файлами з позначками "name" та "age".
+Отриманий об'єкт `user` можна уявити собі як шафу з двома підписаними файлами з позначками "name" та "age".
 
 ![user object](object-user.svg)
 
@@ -49,7 +49,7 @@ let user = {     // об’єкт
 Для звернення до властивостей використовується запис через крапку:
 
 ```js
-// отримаємо значення властивостей об’єкта:
+// отримаємо значення властивостей об'єкта:
 alert( user.name ); // Іван
 alert( user.age ); // 30
 ```
@@ -70,13 +70,13 @@ delete user.age;
 
 ![user object 3](object-user-delete.svg)
 
-Ім’я властивості може складатися з декількох слів, але тоді воно має бути поміщено в лапки:
+Ім'я властивості може складатися з декількох слів, але тоді воно має бути поміщено в лапки:
 
 ```js
 let user = {
   name: "Іван",
   age: 30,
-  "likes birds": true  // Ім’я властивості з декількох слів повинно бути в лапках
+  "likes birds": true  // Ім'я властивості з декількох слів повинно бути в лапках
 };
 ```
 
@@ -105,7 +105,7 @@ JavaScript бачить, що ми звертаємося до властиво
 
 Крапка вимагає, щоб ключ був правильним ідентифікатором змінної. Це означає: не містить пробілів, не починається з цифри та не містить спеціальних символів (`$` та `_` дозволені).
 
-Для таких випадків існує альтернативний спосіб доступу до властивостей через квадратні дужки. Такий спосіб спрацює з будь-яким ім’ям властивості:
+Для таких випадків існує альтернативний спосіб доступу до властивостей через квадратні дужки. Такий спосіб спрацює з будь-яким ім'ям властивості:
 
 ```js run
 let user = {};
@@ -122,7 +122,7 @@ delete user["любить птахів"];
 
 Зараз усе гаразд. Зверніть увагу, що рядок у квадратних дужках міститься в лапках (підійде будь-який тип лапок).
 
-Квадратні дужки також дозволяють звернутися до властивості, ім’я якої може бути результатом виразу. Наприклад, ім'я властивості може зберігатися в змінній:
+Квадратні дужки також дозволяють звернутися до властивості, ім'я якої може бути результатом виразу. Наприклад, ім'я властивості може зберігатися в змінній:
 
 ```js
 let key = "любить птахів";
@@ -179,7 +179,7 @@ alert( bag.apple ); // 5 якщо fruit="apple"
 
 Значення обчислюваної властивості просте: `[fruit]` означає, що назву властивості слід брати з `fruit`.
 
-І якщо відвідувач введе слово `"apple"`, то в об’єкті `bag` тепер буде лежати властивість `{apple: 5}`.
+І якщо відвідувач введе слово `"apple"`, то в об'єкті `bag` тепер буде лежати властивість `{apple: 5}`.
 
 По суті, це працює так само, як:
 ```js run
@@ -240,7 +240,7 @@ function makeUser(name, age) {
 }
 ```
 
-Ми можемо використовувати як звичайні властивості, так і скорочення в одному об’єкті:
+Ми можемо використовувати як звичайні властивості, так і скорочення в одному об'єкті:
 
 ```js
 let user = {
@@ -252,9 +252,9 @@ let user = {
 
 ## Обмеження для імен властивостей
 
-Як ми вже знаємо, змінна не може мати ім’я, зі списку слів, зарезервованих мовою, як-от "for", "let", "return" тощо.
+Як ми вже знаємо, змінна не може мати ім'я, зі списку слів, зарезервованих мовою, як-от "for", "let", "return" тощо.
 
-То для властивості об’єкта немає такого обмеження:
+То для властивості об'єкта немає такого обмеження:
 
 ```js run
 // ці назви властивостей -- правильні
@@ -283,12 +283,12 @@ alert( obj["0"] ); // тест
 alert( obj[0] ); // тест (таж сама властивість)
 ```
 
-Є невеликий підводний камінь, пов’язаний зі спеціальною властивістю `__proto__`. Ми можемо встановити в нього значення об’єктного типу:
+Є невеликий підводний камінь, пов'язаний зі спеціальною властивістю `__proto__`. Ми можемо встановити в нього значення об'єктного типу:
 
 ```js run
 let obj = {};
 obj.__proto__ = 5; // присвоїмо число
-alert(obj.__proto__); // [object Object] - значення -- це об’єкт, тобто не те, що ми очікували
+alert(obj.__proto__); // [object Object] - значення -- це об'єкт, тобто не те, що ми очікували
 ```
 
 Як ми бачимо з коду, присвоєння числа `5` ігнорується.
@@ -297,7 +297,7 @@ alert(obj.__proto__); // [object Object] - значення -- це об’єк
 
 ## Перевірка існування властивості, оператор "in"
 
-Помітною особливістю об’єктів у JavaScript, у порівнянні з багатьма іншими мовами, є можливість доступу до будь-якої властивості. Помилки не буде, якщо властивості не існує!
+Помітною особливістю об'єктів у JavaScript, у порівнянні з багатьма іншими мовами, є можливість доступу до будь-якої властивості. Помилки не буде, якщо властивості не існує!
 
 Читання відсутньої властивості просто повертає `undefined`. Тому ми можемо легко перевірити, чи існує властивість:
 
@@ -323,9 +323,9 @@ alert( "age" in user ); // true, user.age існує
 alert( "blabla" in user ); // false, user.blabla не існує
 ```
 
-Зверніть увагу, що зліва від оператора `in` повинно бути ім’я властивості. Зазвичай це рядок в лапках.
+Зверніть увагу, що зліва від оператора `in` повинно бути ім'я властивості. Зазвичай це рядок в лапках.
 
-Якщо ми опускаємо лапки, це означає, що ми вказуємо змінну, в якій знаходиться ім’я властивості. Наприклад:
+Якщо ми опускаємо лапки, це означає, що ми вказуємо змінну, в якій знаходиться ім'я властивості. Наприклад:
 
 ```js run
 let user = { age: 30 };
@@ -357,13 +357,13 @@ alert( "test" in obj ); // true, властивість існує!
 
 ## Цикл "for..in" [#forin]
 
-Для перебору всіх властивостей об’єкта використовується цикл `for..in`. Цей цикл відрізняється від вивченого раніше циклу `for(;;)`.
+Для перебору всіх властивостей об'єкта використовується цикл `for..in`. Цей цикл відрізняється від вивченого раніше циклу `for(;;)`.
 
 Синтаксис:
 
 ```js
 for (key in object) {
-  // тіло циклу виконується для кожної властивості об’єкта
+  // тіло циклу виконується для кожної властивості об'єкта
 }
 ```
 
@@ -386,15 +386,15 @@ for (let key in user) {
 
 Зверніть увагу, що всі конструкції "for" дозволяють нам оголошувати змінну всередині циклу, як, наприклад, `let key` тут.
 
-Крім того, ми могли б використовувати інше ім’я змінної. Наприклад, часто використовується варіант `"for (let prop in obj)"`.
+Крім того, ми могли б використовувати інше ім'я змінної. Наприклад, часто використовується варіант `"for (let prop in obj)"`.
 
-### Впорядкування властивостей об’єкта
+### Впорядкування властивостей об'єкта
 
-Чи упорядковані властивості об’єкта? Іншими словами, якщо ми будемо в циклі перебирати всі властивості об’єкта, чи отримаємо ми їх в тому ж порядку, в якому ми їх додавали? Чи можемо ми на це розраховувати?
+Чи упорядковані властивості об'єкта? Іншими словами, якщо ми будемо в циклі перебирати всі властивості об'єкта, чи отримаємо ми їх в тому ж порядку, в якому ми їх додавали? Чи можемо ми на це розраховувати?
 
 Коротка відповідь: "властивості впорядковані особливим чином". Властивості з цілочисельними ключами сортуються за зростанням, інші розташовуються в порядку створення. Розберемося докладніше.
 
-Як приклад розглянемо об’єкт з телефонними кодами:
+Як приклад розглянемо об'єкт з телефонними кодами:
 
 ```js run
 let codes ={
@@ -412,7 +412,7 @@ for (let code in codes) {
 */!*
 ```
 
-Об’єкт може використовуватися, щоб запропонувати користувачеві список опцій. Якщо ми робимо сайт для німецької аудиторії, то, ймовірно, ми хочемо, щоб код `49` був першим.
+Об'єкт може використовуватися, щоб запропонувати користувачеві список опцій. Якщо ми робимо сайт для німецької аудиторії, то, ймовірно, ми хочемо, щоб код `49` був першим.
 
 Але якщо ми запустимо код, ми побачимо зовсім іншу картину:
 
@@ -424,7 +424,7 @@ for (let code in codes) {
 ````smart header="Цілочисельні властивості? Що це?"
 Термін "цілочисельна властивість" означає рядок, який може бути перетворений в ціле число і назад без змін.
 
-Тобто, рядок `"49"` -- це цілочисельне ім’я властивості, якщо його перетворити на ціле число, а потім назад в рядок, то воно не зміниться. А ось властивості `"+49"` або `"1.2"` такими не є:
+Тобто, рядок `"49"` -- це цілочисельне ім'я властивості, якщо його перетворити на ціле число, а потім назад в рядок, то воно не зміниться. А ось властивості `"+49"` або `"1.2"` такими не є:
 
 ```js run
 // Number(...) -- явно перетворює на число
@@ -474,7 +474,7 @@ for (let code in codes) {
 
 ## Висновок
 
-Об’єкти -- це асоціативні масиви з рядом додаткових можливостей.
+Об'єкти -- це асоціативні масиви з рядом додаткових можливостей.
 
 Вони зберігають властивості (пари ключ-значення), де:
 - Ключі властивостей повинні бути рядками або символами (зазвичай рядками).
@@ -487,11 +487,11 @@ for (let code in codes) {
 Додаткові оператори:
 - Видалення властивості: `delete obj.prop`.
 - Перевірка існування властивості: `"key" in obj`.
-- Перебір властивостей об’єкта: цикл `for (let key in obj)`.
+- Перебір властивостей об'єкта: цикл `for (let key in obj)`.
 
-Те, що ми вивчали в цьому розділі, називається "простим об’єктом" або просто `Object`.
+Те, що ми вивчали в цьому розділі, називається "простим об'єктом" або просто `Object`.
 
-В JavaScript є багато інших типів об’єктів:
+В JavaScript є багато інших типів об'єктів:
 
 - `Array` для зберігання впорядкованих колекцій даних,
 - `Date` для зберігання інформації про дату і час,
@@ -500,4 +500,4 @@ for (let code in codes) {
 
 У них є свої особливості, які ми вивчимо пізніше. Іноді люди говорять щось на кшталт "тип даних Array" або "тип даних Date", але формально вони не є окремими типами, а належать до типу даних `"Object"`. Вони лише розширюють його різними способами.
 
-Об’єкти в JavaScript дуже потужні. Тут ми тільки трохи заглибилися в дійсно величезну тему. Ми будемо тісно працювати з об’єктами і дізнаємося про них більше в наступних частинах підручника.
+Об'єкти в JavaScript дуже потужні. Тут ми тільки трохи заглибилися в дійсно величезну тему. Ми будемо тісно працювати з об'єктами і дізнаємося про них більше в наступних частинах підручника.
diff --git a/1-js/04-object-basics/02-object-copy/article.md b/1-js/04-object-basics/02-object-copy/article.md
index e5192f1f0..ac545cece 100644
--- a/1-js/04-object-basics/02-object-copy/article.md
+++ b/1-js/04-object-basics/02-object-copy/article.md
@@ -1,6 +1,6 @@
-# Копіювання об’єктів та посилання
+# Копіювання об'єктів та посилання
 
-Однією з принципових відмінностей об’єктів від примітивів є те, що об’єкти зберігаються та копіюються "за посиланням", тоді як примітивні значення: рядки, числа, логічні значення тощо - завжди копіюються "за значенням".
+Однією з принципових відмінностей об'єктів від примітивів є те, що об'єкти зберігаються та копіюються "за посиланням", тоді як примітивні значення: рядки, числа, логічні значення тощо - завжди копіюються "за значенням".
 
 Це легко зрозуміти, якщо заглянути під капот того, що відбувається, коли ми копіюємо значення.
 
@@ -19,9 +19,9 @@ let phrase = message;
 
 Цілком очікуванний результат, згодні?
 
-Об’єкти поводяться інакше.
+Об'єкти поводяться інакше.
 
-**Змінна зберігає не сам об’єкт, а його "адресу в пам’яті" -- іншими словами "посилання" на нього.**
+**Змінна зберігає не сам об'єкт, а його "адресу в пам'яті" -- іншими словами "посилання" на нього.**
 
 Проілюструємо це:
 
@@ -31,19 +31,19 @@ let user = {
 };
 ```
 
-І ось як це насправді зберігається в пам’яті:
+І ось як це насправді зберігається в пам'яті:
 
 ![](variable-contains-reference.svg)
 
-Об’єкт зберігається десь у пам’яті (справа на зображенні), тоді як у змінній `user` (зліва) є "посилання" на нього.
+Об'єкт зберігається десь у пам'яті (справа на зображенні), тоді як у змінній `user` (зліва) є "посилання" на нього.
 
-Ми можемо думати про змінну `user`, як про шухляду з аркушем паперу з адресою об’єкта на ньому.
+Ми можемо думати про змінну `user`, як про шухляду з аркушем паперу з адресою об'єкта на ньому.
 
-Коли ми виконуємо дії з об’єктом, напр. зчитуємо властивість `user.name`, рушій JavaScript перевіряє, що знаходиться за цією адресою, і виконує операцію над фактичним об’єктом.
+Коли ми виконуємо дії з об'єктом, напр. зчитуємо властивість `user.name`, рушій JavaScript перевіряє, що знаходиться за цією адресою, і виконує операцію над фактичним об'єктом.
 
 Ось чому це важливо:
 
-**Коли копіюється змінна об’єкта, копіюється посилання, але сам об’єкт не дублюється.**
+**Коли копіюється змінна об'єкта, копіюється посилання, але сам об'єкт не дублюється.**
 
 Наприклад:
 
@@ -53,13 +53,13 @@ let user = { name: "Іван" };
 let admin = user; // копіювання посилання
 ```
 
-Тепер у нас є дві змінні, кожна з яких зберігає посилання на той самий об’єкт:
+Тепер у нас є дві змінні, кожна з яких зберігає посилання на той самий об'єкт:
 
 ![](variable-copy-reference.svg)
 
-Як бачите, є тільки один об’єкт, але тепер із двома змінними, які посилаються на нього.
+Як бачите, є тільки один об'єкт, але тепер із двома змінними, які посилаються на нього.
 
-Ми можемо використати будь-яку змінну для доступу до об’єкта та модифікації його вмісту:
+Ми можемо використати будь-яку змінну для доступу до об'єкта та модифікації його вмісту:
 
 ```js run
 let user = { name: 'Іван' };
@@ -73,35 +73,35 @@ admin.name = 'Петро'; // змінено за посиланням зі зм
 alert(*!*user.name*/!*); // 'Петро', зміни видно з посилання зі змінної "user"
 ```
 
-Уявіть, що об’єкт -- це шафа з якимись данними (властивостями). А "адреса" цієї шафи зберігається у двох шухлядах. Спочатку ми використовуємо одну з них (`admin`), щоб дістатися цієї шафи та щось змінити. Потім, якщо ми використаємо іншу шухляду (`user`), ми все ще відкриємо ту саму шафу і отримаємо доступ до зміненого вмісту.
+Уявіть, що об'єкт -- це шафа з якимись данними (властивостями). А "адреса" цієї шафи зберігається у двох шухлядах. Спочатку ми використовуємо одну з них (`admin`), щоб дістатися цієї шафи та щось змінити. Потім, якщо ми використаємо іншу шухляду (`user`), ми все ще відкриємо ту саму шафу і отримаємо доступ до зміненого вмісту.
 
 ## Порівняння за посиланням
 
-Два об’єкти рівні, лише якщо це той самий об’єкт.
+Два об'єкти рівні, лише якщо це той самий об'єкт.
 
-Наприклад, тут `a` і` b` посилаються на той самий об’єкт, отже, вони рівні:
+Наприклад, тут `a` і` b` посилаються на той самий об'єкт, отже, вони рівні:
 
 ```js run
 let a = {};
 let b = a; // копіювання посилання
 
-alert( a == b ); // true, обидві змінні посилаються на той самий об’єкт
+alert( a == b ); // true, обидві змінні посилаються на той самий об'єкт
 alert( a === b ); // true
 ```
 
-І тут два незалежні об’єкти не рівні, хоча вони схожі (обидва порожні):
+І тут два незалежні об'єкти не рівні, хоча вони схожі (обидва порожні):
 
 ```js run
 let a = {};
-let b = {}; // два незалежні об’єкти
+let b = {}; // два незалежні об'єкти
 
 alert( a == b ); // false
 ```
 
-Для порівнянь, таких як `obj1 > obj2`, або для порівняння з примітивом `obj == 5`, об’єкти перетворюються на примітиви. Незабаром ми вивчимо, як працюють перетворення об’єктів, але правду кажучи, такі порівняння потрібні вкрай рідко — зазвичай вони з’являються в результаті неправильного програмування.
+Для порівнянь, таких як `obj1 > obj2`, або для порівняння з примітивом `obj == 5`, об'єкти перетворюються на примітиви. Незабаром ми вивчимо, як працюють перетворення об'єктів, але правду кажучи, такі порівняння потрібні вкрай рідко — зазвичай вони з'являються в результаті неправильного програмування.
 
-````smart header="Об’єкти у const-змінних можна змінювати"
-Важливим побічним ефектом зберігання об’єктів як посилань є те, що об’єкт, оголошений як `const`, *може* бути змінений.
+````smart header="Об'єкти у const-змінних можна змінювати"
+Важливим побічним ефектом зберігання об'єктів як посилань є те, що об'єкт, оголошений як `const`, *може* бути змінений.
 
 Наприклад:
 
@@ -117,20 +117,20 @@ user.name = "Петро"; // (*)
 alert(user.name); // Петро
 ```
 
-Може здатися, що рядок `(*)` призведе до помилки, але це не так. Значення у змінній `user` є постійним, воно завжди має посилатися на той самий об’єкт, але властивості цього об’єкта можуть змінюватися.
+Може здатися, що рядок `(*)` призведе до помилки, але це не так. Значення у змінній `user` є постійним, воно завжди має посилатися на той самий об'єкт, але властивості цього об'єкта можуть змінюватися.
 
 Інакше кажучи, `const user` видає помилку, лише якщо ми намагаємося присвоїти у саму змінну інше значення: `user = ...`.
 
-Тим не менш, якщо нам дійсно потрібно створювати незмінні властивості об’єкта, це також можливо, але з використанням зовсім інших методів. Про це ми згадаємо у розділі <info:property-descriptors>.
+Тим не менш, якщо нам дійсно потрібно створювати незмінні властивості об'єкта, це також можливо, але з використанням зовсім інших методів. Про це ми згадаємо у розділі <info:property-descriptors>.
 ````
 
-## Клонування та злиття об’єктів, Object.assign [#cloning-and-merging-object-assign]
+## Клонування та злиття об'єктів, Object.assign [#cloning-and-merging-object-assign]
 
-Отже, копіювання змінної об’єкта створює ще одне посилання на той самий об’єкт.
+Отже, копіювання змінної об'єкта створює ще одне посилання на той самий об'єкт.
 
 Але що, якщо нам потрібно створити копію, клон об'єкта?
 
-Але якщо ми насправді цього хочемо, то нам потрібно створити новий об’єкт і відтворити структуру існуючого, перебираючи та копіюючи його властивості.
+Але якщо ми насправді цього хочемо, то нам потрібно створити новий об'єкт і відтворити структуру існуючого, перебираючи та копіюючи його властивості.
 
 Наприклад так:
 
@@ -165,9 +165,9 @@ Object.assign(dest, ...sources)
 - Перший аргумент `dest` є цільовим об'єктом.
 - Подальші аргументи -- це список вихідних об'єктів.
 
-Він копіює властивості всіх вихідних об’єктів у цільовий `dest`, а потім повертає його як результат.
+Він копіює властивості всіх вихідних об'єктів у цільовий `dest`, а потім повертає його як результат.
 
-Наприклад, у нас є об’єкт `user`, давайте додамо до нього пару властивостей з дозволами:
+Наприклад, у нас є об'єкт `user`, давайте додамо до нього пару властивостей з дозволами:
 
 ```js run
 let user = { name: "Микола" };
@@ -196,7 +196,7 @@ Object.assign(user, { name: "Петро" });
 alert(user.name); // now user = { name: "Петро" }
 ```
 
-Ми також можемо використовувати `Object.assign` щоб виконати просте клонування об’єкта:
+Ми також можемо використовувати `Object.assign` щоб виконати просте клонування об'єкта:
 
 ```js run
 let user = {
@@ -211,13 +211,13 @@ let clone = Object.assign({}, user);
 alert(clone.name); // Микола
 alert(clone.age); // 30
 ```
-Він копіює всі властивості `user` в порожній об’єкт і повертає його.
+Він копіює всі властивості `user` в порожній об'єкт і повертає його.
 
-Існують також інші методи клонування об’єкта, напр. [spread syntax](info:rest-parameters-spread) `clone = {...user}`, розглянуті далі в посібнику.
+Існують також інші методи клонування об'єкта, напр. [spread syntax](info:rest-parameters-spread) `clone = {...user}`, розглянуті далі в посібнику.
 
 ## Вкладене клонування
 
-Досі ми припускали, що всі властивості `user` є примітивами. Але властивості можуть бути посиланнями на інші об’єкти.
+Досі ми припускали, що всі властивості `user` є примітивами. Але властивості можуть бути посиланнями на інші об'єкти.
 
 Ось так:
 ```js run
@@ -232,7 +232,7 @@ let user = {
 alert( user.sizes.height ); // 182
 ```
 
-Тепер недостатньо скопіювати `clone.sizes = user.sizes`, тому що `user.sizes` є об’єктом і буде скопійовано за посиланням, тому `clone` і `user` матимуть однакові `sizes`:
+Тепер недостатньо скопіювати `clone.sizes = user.sizes`, тому що `user.sizes` є об'єктом і буде скопійовано за посиланням, тому `clone` і `user` матимуть однакові `sizes`:
 
 ```js run
 let user = {
@@ -280,9 +280,9 @@ user.sizes.width = 60;    // тепер змінюємо властивість
 alert(clone.sizes.width); // 50, інше місце не пов'язане з попереднім
 ```
 
-Метод `structuredClone` може клонувати більшість типів даних, таких як об’єкти, масиви, примітивні значення.
+Метод `structuredClone` може клонувати більшість типів даних, таких як об'єкти, масиви, примітивні значення.
 
-Він також підтримує циклічні посилання, коли властивість об’єкта посилається на сам об’єкт (безпосередньо або через ланцюжок чи посилання).
+Він також підтримує циклічні посилання, коли властивість об'єкта посилається на сам об'єкт (безпосередньо або через ланцюжок чи посилання).
 
 Наприклад:
 
@@ -300,7 +300,7 @@ alert(clone.me === clone); // true
 
 Хоча бувають випадки, коли `structuredClone` не працює.
 
-Наприклад, коли об’єкт має властивість з функцією:
+Наприклад, коли об'єкт має властивість з функцією:
 
 ```js run
 // помилка
@@ -315,8 +315,8 @@ structuredClone({
 
 ## Підсумки
 
-Об’єкти присвоюються та копіюються за посиланням. Інакше кажучи, змінна зберігає не "значення об’єкта", а "посилання" (адресу в пам’яті) на значення. Тож копіювання такої змінної або передача її як аргументу функції копіює це посилання, а не сам об’єкт.
+Об'єкти присвоюються та копіюються за посиланням. Інакше кажучи, змінна зберігає не "значення об'єкта", а "посилання" (адресу в пам'яті) на значення. Тож копіювання такої змінної або передача її як аргументу функції копіює це посилання, а не сам об'єкт.
 
-Усі операції за допомогою скопійованих посилань (наприклад, додавання/видалення властивостей) виконуються над тим самим об’єктом.
+Усі операції за допомогою скопійованих посилань (наприклад, додавання/видалення властивостей) виконуються над тим самим об'єктом.
 
-Для створення "справжньої копії" (клону) ми можемо використовувати `Object.assign` для так званої "поверхової копії" (вкладені об’єкти копіюються за посиланням) або функції "глибокого клонування", наприклад [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+Для створення "справжньої копії" (клону) ми можемо використовувати `Object.assign` для так званої "поверхової копії" (вкладені об'єкти копіюються за посиланням) або функції "глибокого клонування", наприклад [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
diff --git a/1-js/04-object-basics/03-garbage-collection/article.md b/1-js/04-object-basics/03-garbage-collection/article.md
index a35dbcd06..5599bf993 100644
--- a/1-js/04-object-basics/03-garbage-collection/article.md
+++ b/1-js/04-object-basics/03-garbage-collection/article.md
@@ -1,14 +1,14 @@
 # Збирання сміття
 
-Управління пам’яттю в JavaScript виконується автоматично і непомітно. Ми створюємо примітиви, об’єкти, функції... Все це займає пам’ять.
+Управління пам'яттю в JavaScript виконується автоматично і непомітно. Ми створюємо примітиви, об'єкти, функції... Все це займає пам'ять.
 
-Але що відбувається, коли змінна або якийсь об’єкт більше не потрібні? Як JavaScript розуміє, коли потрібно звільняти пам’ять?
+Але що відбувається, коли змінна або якийсь об'єкт більше не потрібні? Як JavaScript розуміє, коли потрібно звільняти пам'ять?
 
 ## Досяжність
 
-Основна концепція управління пам’яттю в JavaScript -- це *досяжність*.
+Основна концепція управління пам'яттю в JavaScript -- це *досяжність*.
 
-Простіше кажучи, "досяжні" значення -- це ті, які якимось чином доступні або придатні для використання. Вони гарантовано зберігаються в пам’яті.
+Простіше кажучи, "досяжні" значення -- це ті, які якимось чином доступні або придатні для використання. Вони гарантовано зберігаються в пам'яті.
 
 1. Існує базовий набір досяжних за своєю суттю значень, які неможливо видалити із зрозумілих причин.
 
@@ -23,16 +23,16 @@
 
 2. Будь-яке інше значення вважається досяжним, якщо воно доступне з кореня за допомогою посилання або ланцюжка посилань.
 
-    Наприклад, якщо в глобальній змінній є об’єкт, і цей об’єкт має властивість, що посилається на інший об’єкт, *цей* об’єкт вважається досяжним. І ті, на які він посилається, також досяжні. Далі ви познайомитеся з докладними прикладами на цю тему.
+    Наприклад, якщо в глобальній змінній є об'єкт, і цей об'єкт має властивість, що посилається на інший об'єкт, *цей* об'єкт вважається досяжним. І ті, на які він посилається, також досяжні. Далі ви познайомитеся з докладними прикладами на цю тему.
 
-У рушію JavaScript є фоновий процес, який називається [збирання сміття](https://uk.wikipedia.org/wiki/Збирання_сміття). Він контролює всі об’єкти та видаляє ті, які стали недосяжними.
+У рушію JavaScript є фоновий процес, який називається [збирання сміття](https://uk.wikipedia.org/wiki/Збирання_сміття). Він контролює всі об'єкти та видаляє ті, які стали недосяжними.
 
 ## Простий приклад
 
 Ось найпростіший приклад:
 
 ```js
-// user має посилання на об’єкт
+// user має посилання на об'єкт
 let user = {
   name: "Іван"
 };
@@ -40,7 +40,7 @@ let user = {
 
 ![](memory-user-john.svg)
 
-Тут стрілка зображує посилання на об’єкт. Глобальна змінна `"user"` посилається на об’єкт `{name: "Іван"}` (ми будемо називати його Іван для стислості). Властивість `"name"` Івана зберігає примітив, тому він зображений всередині об’єкта.
+Тут стрілка зображує посилання на об'єкт. Глобальна змінна `"user"` посилається на об'єкт `{name: "Іван"}` (ми будемо називати його Іван для стислості). Властивість `"name"` Івана зберігає примітив, тому він зображений всередині об'єкта.
 
 Якщо значення в змінній `user` переписується, посилання втрачається:
 
@@ -50,14 +50,14 @@ user = null;
 
 ![](memory-user-john-lost.svg)
 
-Тепер Іван стає недосяжним. Немає доступу до нього, немає посилань на нього. Процес збирання сміття видалить дані і звільнить пам’ять.
+Тепер Іван стає недосяжним. Немає доступу до нього, немає посилань на нього. Процес збирання сміття видалить дані і звільнить пам'ять.
 
 ## Два посилання
 
 Тепер уявімо, що ми скопіювали посилання зі змінної `user` у змінну `admin`:
 
 ```js
-// user має посилання на об’єкт
+// user має посилання на об'єкт
 let user = {
   name: "Іван"
 };
@@ -74,11 +74,11 @@ let admin = user;
 user = null;
 ```
 
-...Тепер об’єкт все ще є досяжним через глобальну змінну `admin`, таким чином він залишається у пам’яті. Якщо переписати змінну `admin` також, його можна буде видалити.
+...Тепер об'єкт все ще є досяжним через глобальну змінну `admin`, таким чином він залишається у пам'яті. Якщо переписати змінну `admin` також, його можна буде видалити.
 
-## Взаємозв’язані об’єкти
+## Взаємозв'язані об'єкти
 
-Тепер більш складний приклад. Сім’я:
+Тепер більш складний приклад. Сім'я:
 
 ```js
 function marry(man, woman) {
@@ -98,13 +98,13 @@ let family = marry({
 });
 ```
 
-Функція `marry` "одружує" два об’єкти, даючи їм посилання один на одного та повертаючи новий об’єкт, що містить їх обох.
+Функція `marry` "одружує" два об'єкти, даючи їм посилання один на одного та повертаючи новий об'єкт, що містить їх обох.
 
 Отримана структура даних:
 
 ![](family.svg)
 
-Наразі всі об’єкти досяжні.
+Наразі всі об'єкти досяжні.
 
 Тепер видалимо два посилання:
 
@@ -115,13 +115,13 @@ delete family.mother.husband;
 
 ![](family-delete-refs.svg)
 
-Недостатньо видалити лише одне з цих двох посилань, оскільки всі об’єкти все одно будуть досяжними.
+Недостатньо видалити лише одне з цих двох посилань, оскільки всі об'єкти все одно будуть досяжними.
 
 Але якщо видалити обидва, то можна побачити, що Іван більше не має посилань на себе:
 
 ![](family-no-father.svg)
 
-Вихідні посилання не мають значення. Тільки вхідні можуть зробити об’єкт досяжним. Отже, Іван зараз недосяжний і буде видалений з пам’яті з усіма його даними, які також стали недосяжними.
+Вихідні посилання не мають значення. Тільки вхідні можуть зробити об'єкт досяжним. Отже, Іван зараз недосяжний і буде видалений з пам'яті з усіма його даними, які також стали недосяжними.
 
 Після збирання сміття:
 
@@ -129,9 +129,9 @@ delete family.mother.husband;
 
 ## Недосяжний "острів"
 
-Можливо, що весь "острів" взаємопов’язаних об’єктів стане недосяжним і видалиться з пам’яті.
+Можливо, що весь "острів" взаємопов'язаних об'єктів стане недосяжним і видалиться з пам'яті.
 
-Якщо об’єкт такий самий, як і вище, тоді:
+Якщо об'єкт такий самий, як і вище, тоді:
 
 ```js
 family = null;
@@ -143,9 +143,9 @@ family = null;
 
 Цей приклад демонструє, наскільки важливою є концепція досяжності.
 
-Очевидно, що Іван і Анна все ще пов’язані, обидва мають вхідні посилання. Але цього недостатньо.
+Очевидно, що Іван і Анна все ще пов'язані, обидва мають вхідні посилання. Але цього недостатньо.
 
-Колишній об’єкт `"family"` було від’єднано від кореня, більше на нього немає посилання, тому весь "острів" стає недосяжним і буде видалений.
+Колишній об'єкт `"family"` було від'єднано від кореня, більше на нього немає посилання, тому весь "острів" стає недосяжним і буде видалений.
 
 ## Внутрішні алгоритми
 
@@ -155,11 +155,11 @@ family = null;
 
 - Збирання сміття розпочинається з коренів, які позначаються (запам'ятовуються) особливим чином.
 - Потім позначаються всі посилання від них.
-- Потім він відвідує позначені об’єкти та позначає інші об’єкти на які є посилання від них. Усі відвідані об’єкти запам’ятовуються, щоб у майбутньому не відвідувати один і той же об’єкт двічі.
+- Потім він відвідує позначені об'єкти та позначає інші об'єкти на які є посилання від них. Усі відвідані об'єкти запам'ятовуються, щоб у майбутньому не відвідувати один і той же об'єкт двічі.
 - ...І так до тих пір, поки не будуть відвідані усі досяжні (з коренів) посилання.
-- Усі об’єкти, крім позначених, видаляються.
+- Усі об'єкти, крім позначених, видаляються.
 
-Наприклад, нехай наша структура об’єктів виглядатиме так:
+Наприклад, нехай наша структура об'єктів виглядатиме так:
 
 ![](garbage-collection-1.svg)
 
@@ -177,18 +177,18 @@ family = null;
 
 ![](garbage-collection-4.svg)
 
-Тепер об’єкти, які не вдалося відвідати в процесі, вважаються недосяжними і будуть видалені:
+Тепер об'єкти, які не вдалося відвідати в процесі, вважаються недосяжними і будуть видалені:
 
 ![](garbage-collection-5.svg)
 
-Ми також можемо уявити собі цей процес, як виливання великого відра фарби починаючи з коренів, фарба протікає через усі посилання і позначає всі об’єкти, до яких можна дістатися. Потім непозначені об’єкти видаляються.
+Ми також можемо уявити собі цей процес, як виливання великого відра фарби починаючи з коренів, фарба протікає через усі посилання і позначає всі об'єкти, до яких можна дістатися. Потім непозначені об'єкти видаляються.
 
 Це концепція того, як працює збирання сміття. Рушій JavaScript застосовує багато оптимізацій, щоб прискорити це та не додати затримок при виконанні коду.
 
 Деякі з оптимізацій:
 
-- **Збірка поколінь (Generational collection)** -- об’єкти поділяються на два набори: "нові" та "старі". Багато об'єктів мають короткий термін служби, вони з’являються, виконують свою роботу і швидко стають непотрібними. Тому має сенс відстежувати нові об’єкти та очищати від них пам’ять, якщо це так. Ті, що використовуються досить довго, стають "старими" і оглядаються рідше.
-- **Інкрементний збір (Incremental collection)** -- якщо об’єктів багато, і ми намагаємось пройтися і позначити весь набір об’єктів одночасно, це може зайняти деякий час і ввести видимі затримки у виконанні. Тому рушій намагається розділити збирання сміття на частини. Потім частини виконуються по одній, окремо. Таким чином відбувається багато дрібних зборів сміття замість одного великого. Це вимагає додаткового обліку між ними для відстеження змін, але ми маємо багато маленьких затримок замість однієї великої.
+- **Збірка поколінь (Generational collection)** -- об'єкти поділяються на два набори: "нові" та "старі". Багато об'єктів мають короткий термін служби, вони з'являються, виконують свою роботу і швидко стають непотрібними. Тому має сенс відстежувати нові об'єкти та очищати від них пам'ять, якщо це так. Ті, що використовуються досить довго, стають "старими" і оглядаються рідше.
+- **Інкрементний збір (Incremental collection)** -- якщо об'єктів багато, і ми намагаємось пройтися і позначити весь набір об'єктів одночасно, це може зайняти деякий час і ввести видимі затримки у виконанні. Тому рушій намагається розділити збирання сміття на частини. Потім частини виконуються по одній, окремо. Таким чином відбувається багато дрібних зборів сміття замість одного великого. Це вимагає додаткового обліку між ними для відстеження змін, але ми маємо багато маленьких затримок замість однієї великої.
 - **Збір під час простою (Idle-time collection)** -- завзвичай збирання сміття працює лише під час простою процесора, щоб зменшити можливий вплив на виконання.
 
 Існують й інші оптимізації та варіанти алгоритмів збирання сміття. Але як би нам не хотілося описати їх тут, ми повинні утриматися від цього, тому що різні інтерпретатори JavaScript застосовують різні прийоми і хитрощі. І, що ще важливіше, все змінюється в міру розвитку інтерпретаторів, тому глибше вивчення "заздалегідь" без реальної потреби, ймовірно, не варто того. Якщо, звичайно, це не питання чистого інтересу, нижче для вас будуть деякі посилання.
@@ -198,8 +198,8 @@ family = null;
 Основне, що потрібно знати:
 
 - Збирання сміття здійснюється автоматично. Ми не можемо примусити або запобігти цьому.
-- Об’єкти зберігаються в пам’яті, поки вони досяжні.
-- Посилання -- це не те ж саме, що бути досяжним (з кореня): декілька взаємопов’язаних об’єктів можуть стати недосяжними усі разом. Ми розібрали це в прикладі вище.
+- Об'єкти зберігаються в пам'яті, поки вони досяжні.
+- Посилання -- це не те ж саме, що бути досяжним (з кореня): декілька взаємопов'язаних об'єктів можуть стати недосяжними усі разом. Ми розібрали це в прикладі вище.
 
 Сучасні рушії реалізують передові алгоритми збирання сміття.
 
@@ -207,6 +207,6 @@ family = null;
 
 Якщо ви знайомі з низькорівневим програмуванням, більш детальна інформація про збирання сміття у рушії V8 міститься у статті [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
-[V8 blog](https://v8.dev/) також час від часу публікує статті про зміни в управлінні пам’яттю. Зрозуміло, вам необхідно розуміти, як влаштований всередині рущія V8 в цілому. Про це ви можете прочитати у блозі [Вячеслава Єгорова](https://mrale.ph) який працював одним з інженерів V8. Я кажу: "V8", тому що він найкраще висвітлений статтями в Інтернеті. Для інших інтерпретаторів деякі підходи схожі, але збирання сміття відрізняється в багатьох аспектах.
+[V8 blog](https://v8.dev/) також час від часу публікує статті про зміни в управлінні пам'яттю. Зрозуміло, вам необхідно розуміти, як влаштований всередині рущія V8 в цілому. Про це ви можете прочитати у блозі [Вячеслава Єгорова](https://mrale.ph) який працював одним з інженерів V8. Я кажу: "V8", тому що він найкраще висвітлений статтями в Інтернеті. Для інших інтерпретаторів деякі підходи схожі, але збирання сміття відрізняється в багатьох аспектах.
 
 Глибоке розуміння роботи інтерпретаторів необхідно, коли вам потрібні низькорівневі оптимізації. Було б розумно планувати їх вивчення тільки як наступний крок після вивчення мови JavaScript.
diff --git a/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md b/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md
index 67483b211..d9302680b 100644
--- a/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md
+++ b/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md
@@ -14,11 +14,11 @@ let user = makeUser();
 alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
 ```
 
-Це тому, що правила, які встановлюють `this`, не розглядають оголошення об’єкта. Важливий лише момент виклику метода.
+Це тому, що правила, які встановлюють `this`, не розглядають оголошення об'єкта. Важливий лише момент виклику метода.
 
 Тут значення `this` всередині `makeUser()` є `undefined`, оскільки воно викликається як функція, а не як метод із синтаксисом "через крапку".
 
-Значення `this` є одним для всієї функції, блоки коду та літерали об’єктів на це не впливають.
+Значення `this` є одним для всієї функції, блоки коду та літерали об'єктів на це не впливають.
 
 Отже, `ref: this` дійсно бере значення `this` функції.
 
@@ -26,7 +26,7 @@ alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
 
 ```js run
 function makeUser(){
-  return this; // цього разу немає літерала об’єкта
+  return this; // цього разу немає літерала об'єкта
 }
 
 alert( makeUser().name ); // Error: Cannot read property 'name' of undefined
diff --git a/1-js/04-object-basics/04-object-methods/4-object-property-this/task.md b/1-js/04-object-basics/04-object-methods/4-object-property-this/task.md
index 693ea021d..d56e819c3 100644
--- a/1-js/04-object-basics/04-object-methods/4-object-property-this/task.md
+++ b/1-js/04-object-basics/04-object-methods/4-object-property-this/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Використання "this" в об’єктному літералі
+# Використання "this" в об'єктному літералі
 
-Тут функція `makeUser` повертає об’єкт.
+Тут функція `makeUser` повертає об'єкт.
 
 Який результат доступу до його `ref`? Чому?
 
diff --git a/1-js/04-object-basics/04-object-methods/7-calculator/task.md b/1-js/04-object-basics/04-object-methods/7-calculator/task.md
index 0c1e8e160..eb62f0c36 100644
--- a/1-js/04-object-basics/04-object-methods/7-calculator/task.md
+++ b/1-js/04-object-basics/04-object-methods/7-calculator/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Створіть об'єкт `calculator` з трьома методами:
 
-- `read()` запитує два значення та зберігає їх як властивості об’єкта з іменами `a` та `b` відповідно.
+- `read()` запитує два значення та зберігає їх як властивості об'єкта з іменами `a` та `b` відповідно.
 - `sum()` повертає суму збережених значень.
 - `mul()` множить збережені значення і повертає результат.
 
diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
index e16295a48..7edd419fa 100644
--- a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
+++ b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
@@ -1,4 +1,4 @@
-Рішення полягає у поверненні самого об’єкта з кожного виклику функції.
+Рішення полягає у поверненні самого об'єкта з кожного виклику функції.
 
 ```js run demo
 let ladder = {
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index 70ab9a592..52153ff10 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -1,6 +1,6 @@
-# Методи об’єкту, "this"
+# Методи об'єкту, "this"
 
-Об’єкти зазвичай створюються для представлення сутностей реального світу, таких як користувачі, замовлення тощо:
+Об'єкти зазвичай створюються для представлення сутностей реального світу, таких як користувачі, замовлення тощо:
 
 ```js
 let user = {
@@ -11,7 +11,7 @@ let user = {
 
 І в реальному світі користувач може *діяти*: вибрати щось із кошика для покупок, авторизуватися, виходити із системи тощо.
 
-Дії представлені в JavaScript функціями у властивостях об’єкта.
+Дії представлені в JavaScript функціями у властивостях об'єкта.
 
 ## Приклади методів
 
@@ -32,13 +32,13 @@ user.sayHi = function() {
 user.sayHi(); // Привіт!
 ```
 
-Тут ми щойно використали Function Expression (функціональний вираз) для створення функції та присвоїли її властивості `user.sayHi` об’єкта.
+Тут ми щойно використали Function Expression (функціональний вираз) для створення функції та присвоїли її властивості `user.sayHi` об'єкта.
 
 Потім ми викликали її завдяки `user.sayHi()`. Користувач тепер може говорити!
 
-Функція, яка є властивістю об’єкта, називається його *методом*.
+Функція, яка є властивістю об'єкта, називається його *методом*.
 
-Отже, ми отримали метод `sayHi` об’єкта `user`.
+Отже, ми отримали метод `sayHi` об'єкта `user`.
 
 Звичайно, ми могли б використовувати попередньо оголошену функцію як метод, наприклад:
 
@@ -61,16 +61,16 @@ user.sayHi(); // Привіт!
 ```
 
 ```smart header="Object-oriented programming"
-Коли ми пишемо наш код, використовуючи об’єкти для представлення сутностей, це називається [об’єктно-орієнтоване програмування](https://uk.wikipedia.org/wiki/Об'єктно-орієнтоване_програмування), скорочено: "ООП".
+Коли ми пишемо наш код, використовуючи об'єкти для представлення сутностей, це називається [об'єктно-орієнтоване програмування](https://uk.wikipedia.org/wiki/Об'єктно-орієнтоване_програмування), скорочено: "ООП".
 
-ООП є великою предметною областю і цікавою наукою саме по собі. Як правильно обрати сутності? Як організувати взаємодію між ними? Це архітектура, і на цю тему є чудові книги, такі як "Шаблони проєктування: елементи багаторазового об’єктно-орієнтованого програмного забезпечення" Е. Гамми, Р. Хелма, Р. Джонсона, Дж. Віссідеса або "Об’єктно-орієнтований аналіз та дизайн з застосунками" Г. Буча та ін.
+ООП є великою предметною областю і цікавою наукою саме по собі. Як правильно обрати сутності? Як організувати взаємодію між ними? Це архітектура, і на цю тему є чудові книги, такі як "Шаблони проєктування: елементи багаторазового об'єктно-орієнтованого програмного забезпечення" Е. Гамми, Р. Хелма, Р. Джонсона, Дж. Віссідеса або "Об'єктно-орієнтований аналіз та дизайн з застосунками" Г. Буча та ін.
 ```
 ### Скорочений запис методу
 
-Існує коротший синтаксис для методів в літералі об’єкта:
+Існує коротший синтаксис для методів в літералі об'єкта:
 
 ```js
-// цей об’єкт робить те ж саме
+// цей об'єкт робить те ж саме
 
 user = {
   sayHi: function() {
@@ -90,17 +90,17 @@ user = {
 
 Як було показано, ми можемо опустити `"function"` і написати просто `sayHi()`.
 
-Слід відзначити, що ці позначення не є повністю ідентичними. Існують тонкі відмінності, пов’язані з наслідуванням об’єктів (про які піде мова пізніше), але наразі вони не мають значення. Майже у всіх випадках скорочений синтаксис краще.
+Слід відзначити, що ці позначення не є повністю ідентичними. Існують тонкі відмінності, пов'язані з наслідуванням об'єктів (про які піде мова пізніше), але наразі вони не мають значення. Майже у всіх випадках скорочений синтаксис краще.
 
 ## "this" в методах
 
-Як правило, метод об’єкта повинен отримувати доступ до інформації, що зберігається в об’єкті, для виконання своєї роботи.
+Як правило, метод об'єкта повинен отримувати доступ до інформації, що зберігається в об'єкті, для виконання своєї роботи.
 
-Наприклад, коду всередині `user.sayHi()` може знадобитися ім’я, що зберігається в об’єкті `user`.
+Наприклад, коду всередині `user.sayHi()` може знадобитися ім'я, що зберігається в об'єкті `user`.
 
-**Для доступу до інформації всередині об’єкта метод може використовувати ключове слово `this`.**
+**Для доступу до інформації всередині об'єкта метод може використовувати ключове слово `this`.**
 
-Значенням `this` є об’єкт "перед крапкою", який використовується для виклику методу.
+Значенням `this` є об'єкт "перед крапкою", який використовується для виклику методу.
 
 Наприклад:
 
@@ -111,7 +111,7 @@ let user = {
 
   sayHi() {
 *!*
-    // "this" -- це "поточний об’єкт"
+    // "this" -- це "поточний об'єкт"
     alert(this.name);
 */!*
   }
@@ -123,7 +123,7 @@ user.sayHi(); // Іван
 
 Тут під час виконання коду `user.sayHi()`, значенням `this` буде `user`.
 
-Також можна отримати доступ до об’єкта без цього, посилаючись на нього через зовнішню змінну:
+Також можна отримати доступ до об'єкта без цього, посилаючись на нього через зовнішню змінну:
 
 ```js
 let user = {
@@ -139,7 +139,7 @@ let user = {
 };
 ```
 
-...Але такий код ненадійний. Якщо ми вирішимо скопіювати `user` в іншу змінну, напр. `admin = user` перезаписати `user` чимось іншим, тоді цей код отримає доступ до неправильного об’єкта.
+...Але такий код ненадійний. Якщо ми вирішимо скопіювати `user` в іншу змінну, напр. `admin = user` перезаписати `user` чимось іншим, тоді цей код отримає доступ до неправильного об'єкта.
 
 Це продемонстровано нижче:
 
@@ -181,7 +181,7 @@ function sayHi() {
 
 Значення `this` обчислюється під час виконання і залежить від контексту.
 
-Наприклад, тут одна й та ж функція призначена двом різним об’єктам і має різний "this" при викликах:
+Наприклад, тут одна й та ж функція призначена двом різним об'єктам і має різний "this" при викликах:
 
 ```js run
 let user = { name: "Іван" };
@@ -192,23 +192,23 @@ function sayHi() {
 }
 
 *!*
-// використовуємо одну і ту ж функцію у двох об’єктах
+// використовуємо одну і ту ж функцію у двох об'єктах
 user.f = sayHi;
 admin.f = sayHi;
 */!*
 
 // виклики функцій, приведені нижче, мають різні this
-// "this" всередині функції є посиланням на об’єкт "перед крапкою"
+// "this" всередині функції є посиланням на об'єкт "перед крапкою"
 user.f(); // Іван  (this == user)
 admin.f(); // Адмін  (this == admin)
 
-admin['f'](); // Адмін (неважливо те, як звертатися до методу об’єкта -- через крапку чи квадратні дужки)
+admin['f'](); // Адмін (неважливо те, як звертатися до методу об'єкта -- через крапку чи квадратні дужки)
 ```
 
 Правило просте: якщо `obj.f()` викликано, то `this` це `obj` під час виконання `f`. Так що в даному прикладі це `user` або `admin`.
 
-````smart header="Виклик без об’єкта: `this == undefined`"
-Ми можемо навіть викликати функцію взагалі без об’єкта:
+````smart header="Виклик без об'єкта: `this == undefined`"
+Ми можемо навіть викликати функцію взагалі без об'єкта:
 
 ```js run
 function sayHi() {
@@ -220,17 +220,17 @@ sayHi(); // undefined
 
 В такому випадку `this` є `undefined` в суворому режимі (`"use strict"`). Якщо ми спробуємо звернутися до `this.name` трапиться помилка.
 
-У несуворому режимі значенням `this` в такому випадку буде *глобальний об’єкт* (`window` у браузері, ми дійдемо до нього пізніше в главі [] (інформація: global-object)). Це -- поведінка, яка склалася історично та виправляється завдяки використанню суворого режиму (`"use strict"`).
+У несуворому режимі значенням `this` в такому випадку буде *глобальний об'єкт* (`window` у браузері, ми дійдемо до нього пізніше в главі [] (інформація: global-object)). Це -- поведінка, яка склалася історично та виправляється завдяки використанню суворого режиму (`"use strict"`).
 
-Зазвичай такий виклик є помилкою програмування. Якщо всередині функції є `this`, вона очікує виклику в контексті об’єкта.
+Зазвичай такий виклик є помилкою програмування. Якщо всередині функції є `this`, вона очікує виклику в контексті об'єкта.
 ````
 
 ```smart header="Наслідки вільного `this`"
-Якщо ви прийшли з іншої мови програмування, то ви, мабуть, звикли до ідеї "зв’язаного `this`", де методи, визначені в об’єкті, завжди мають `this`, що посилається на цей об’єкт.
+Якщо ви прийшли з іншої мови програмування, то ви, мабуть, звикли до ідеї "зв'язаного `this`", де методи, визначені в об'єкті, завжди мають `this`, що посилається на цей об'єкт.
 
-В JavaScript `this` є "вільним", його значення обчислюється під час виклику і не залежить від того, де метод був оголошений, а від того, який об’єкт "перед крапкою".
+В JavaScript `this` є "вільним", його значення обчислюється під час виклику і не залежить від того, де метод був оголошений, а від того, який об'єкт "перед крапкою".
 
-Поняття `this`, що визначається в процесі роботи має як плюси, так і мінуси. З одного боку, функцію можна використовувати повторно для різних об’єктів. З іншого боку, більша гнучкість створює більше можливостей для помилок.
+Поняття `this`, що визначається в процесі роботи має як плюси, так і мінуси. З одного боку, функцію можна використовувати повторно для різних об'єктів. З іншого боку, більша гнучкість створює більше можливостей для помилок.
 
 Тут наша позиція полягає не в тому, щоб судити, добре чи погане таке рішення щодо дизайну мови. Ми зрозуміємо, як з цим працювати, як отримати переваги та уникнути проблем.
 ```
@@ -258,13 +258,13 @@ user.sayHi(); // Ілля
 
 ## Підсумки
 
-- Функції, які зберігаються у властивостях об’єкта, називаються "методами".
-- Методи дозволяють об’єктам "діяти" подібно до `object.doSomething()`.
-- Методи можуть посилатися на об’єкт завдяки `this`.
+- Функції, які зберігаються у властивостях об'єкта, називаються "методами".
+- Методи дозволяють об'єктам "діяти" подібно до `object.doSomething()`.
+- Методи можуть посилатися на об'єкт завдяки `this`.
 
 - Значення `this` визначається під час виконання.
 - Коли функція оголошена, вона може використовувати `this`, але саме `this` не має значення, доки функція не буде викликана.
-- Функцію можна копіювати між об’єктами.
-- Коли функція викликається в синтаксисі "методу": `object.method()`, значення `this` під час виклику є `object` – об’єкт перед крапкою.
+- Функцію можна копіювати між об'єктами.
+- Коли функція викликається в синтаксисі "методу": `object.method()`, значення `this` під час виклику є `object` – об'єкт перед крапкою.
 
 Зверніть увагу, що стрілочні функції є особливими: у них немає `this`. Коли всередині стрілочної функції звертаються до `this`, то його значення береться ззовні.
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
index b74655228..6bbe19cff 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
@@ -1,8 +1,8 @@
 Так, це можливо.
 
-Якщо функція повертає об’єкт, тоді `new` повертає його замість `this`.
+Якщо функція повертає об'єкт, тоді `new` повертає його замість `this`.
 
-Так функції `A` та `B` можуть, наприклад, повертати один і той самий об’єкт `obj`, визначений незалежно від цих функцій:
+Так функції `A` та `B` можуть, наприклад, повертати один і той самий об'єкт `obj`, визначений незалежно від цих функцій:
 
 ```js run no-beautify
 let obj = {};
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
index 0d752ea64..428a6b497 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
@@ -2,7 +2,7 @@ importance: 2
 
 ---
 
-# Дві функції - один об’єкт
+# Дві функції - один об'єкт
 
 Чи можливо створити функції `A` та `B`, щоб `new A() == new B()`?
 
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
index c95e5791b..3d8edc99a 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
@@ -4,9 +4,9 @@ importance: 5
 
 # Створити Калькулятор за допомогою конструктора
 
-Створіть функцію-конструктор `Calculator`, який створює об’єкти з трьома методами:
+Створіть функцію-конструктор `Calculator`, який створює об'єкти з трьома методами:
 
-- `read()` запитує два значення за допомогою `prompt` і записує їх у властивості об’єкта з іменами `a` та `b`.
+- `read()` запитує два значення за допомогою `prompt` і записує їх у властивості об'єкта з іменами `a` та `b`.
 - `sum()` повертає суму цих властивостей.
 - `mul()` повертає результат множення даних властивостей.
 
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index 0d3d21dec..1662fd4fb 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Створіть функцію-конструктор `Accumulator(startingValue)`.
 
-Об’єкт, який він створює повинен:
+Об'єкт, який він створює повинен:
 
 - Зберігати "поточне значення" у властивості `value`. Початкове значення має значення аргументу конструктора `startingValue`.
 - Метод `read()` повинен використовувати `prompt` для зчитування нового числа та додавати його до `value`.
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 061980f94..9f9551557 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -1,6 +1,6 @@
 # Конструктори, оператор "new"
 
-Звичайний синтаксис `{...}` дозволяє створити тільки один об’єкт. Проте часто нам потрібно створити багато однотипних об’єктів, таких як, наприклад, користувачі чи елементи меню тощо.
+Звичайний синтаксис `{...}` дозволяє створити тільки один об'єкт. Проте часто нам потрібно створити багато однотипних об'єктів, таких як, наприклад, користувачі чи елементи меню тощо.
 
 Це можна зробити за допомогою функції-конструктора та оператора `"new"`.
 
@@ -8,7 +8,7 @@
 
 Технічно, функції-конструктори -- це звичайні функції. Однак є дві загальні домовленості:
 
-1. Ім’я функції-конструктора повинно починатися з великої літери.
+1. Ім'я функції-конструктора повинно починатися з великої літери.
 2. Функції-конструктори повинні виконуватися лише з оператором `"new"`.
 
 Наприклад:
@@ -29,7 +29,7 @@ alert(user.isAdmin); // false
 
 Коли функція виконується з `new`, відбуваються наступні кроки:
 
-1. Створюється новий порожній об’єкт, якому присвоюється `this`.
+1. Створюється новий порожній об'єкт, якому присвоюється `this`.
 2. Виконується тіло функції. Зазвичай воно модифікує `this`, додає до нього нові властивості.
 3. Повертається значення `this`.
 
@@ -62,12 +62,12 @@ let user = {
 
 Тепер, якщо ми хочемо створити інших користувачів, ми можемо викликати `new User("Ганна")`, `new User("Аліса")` тощо. Така конструкція значно коротша, ніж використання літералів кожного разу, а також легша для читання.
 
-Це і є основною метою конструкторів -- зручне перевикористання коду зі створення об’єктів.
+Це і є основною метою конструкторів -- зручне перевикористання коду зі створення об'єктів.
 
-Ще раз зауважимо -- технічно будь-яка функція (окрім стрілкових функцій, оскільки вони не мають власного `this`) може бути використана як конструктор. Вона може бути запущена через `new`, і буде виконано наведений вище алгоритм. "Ім’я з великої літери" це загальна домовленість, яка допомагає чітко зрозуміти, що функцію слід запускати з `new`.
+Ще раз зауважимо -- технічно будь-яка функція (окрім стрілкових функцій, оскільки вони не мають власного `this`) може бути використана як конструктор. Вона може бути запущена через `new`, і буде виконано наведений вище алгоритм. "Ім'я з великої літери" це загальна домовленість, яка допомагає чітко зрозуміти, що функцію слід запускати з `new`.
 
 ````smart header="new function() { ... }"
-Якщо у нас є багато рядків коду, які створюють єдиний складний об’єкт, ми можемо обернути їх у функцію-конструктор, яка одразу буде викликана, таким чином:
+Якщо у нас є багато рядків коду, які створюють єдиний складний об'єкт, ми можемо обернути їх у функцію-конструктор, яка одразу буде викликана, таким чином:
 
 ```js
 // створити функцію і негайно викликати її за допомогою new
@@ -81,7 +81,7 @@ let user = new function() {
 };
 ```
 
-Цей конструктор не можна викликати знову, оскільки він ніде не зберігається, а лише створюється і викликається. Отже, такий прийом спрямований на інкапсуляцію коду, який створює єдиний об’єкт, без подальшого повторного використання.
+Цей конструктор не можна викликати знову, оскільки він ніде не зберігається, а лише створюється і викликається. Отже, такий прийом спрямований на інкапсуляцію коду, який створює єдиний об'єкт, без подальшого повторного використання.
 ````
 
 ## Перевірка виклику у режимі конструктора: new.target
@@ -129,7 +129,7 @@ alert(john.name); // Джон
 
 Цей підхід іноді використовується в бібліотеках для створення більш гнучкого синтаксису, який дозволив би розробникам викликати функцію як з оператором `new`, так і без нього.
 
-Проте використання такого підходу скрізь не є хорошою практикою, тому що відсутність `new` робить код менш очевидним. З оператором `new` ми усі знаємо, що буде створено новий об’єкт.
+Проте використання такого підходу скрізь не є хорошою практикою, тому що відсутність `new` робить код менш очевидним. З оператором `new` ми усі знаємо, що буде створено новий об'єкт.
 
 ## Повернення значення з конструктора return
 
@@ -137,22 +137,22 @@ alert(john.name); // Джон
 
 Але якщо є інструкція `return`, то застосовується просте правило:
 
-- Якщо `return` викликається з об’єктом, тоді замість `this` буде повернено цей об’єкт.
+- Якщо `return` викликається з об'єктом, тоді замість `this` буде повернено цей об'єкт.
 - Якщо `return` викликається з примітивом, примітив ігнорується.
 
-Інакше кажучи, `return` з об’єктом повертає цей об’єкт, у всіх інших випадках повертається `this`.
+Інакше кажучи, `return` з об'єктом повертає цей об'єкт, у всіх інших випадках повертається `this`.
 
-У наступному прикладі `return` перезаписує `this`, повертаючи об’єкт:
+У наступному прикладі `return` перезаписує `this`, повертаючи об'єкт:
 
 ```js run
 function BigUser() {
 
   this.name = "Джон";
 
-  return { name: "Ґодзілла" };  // <-- повертає цей об’єкт
+  return { name: "Ґодзілла" };  // <-- повертає цей об'єкт
 }
 
-alert( new BigUser().name );  // Ґодзілла, отримали цей об’єкт
+alert( new BigUser().name );  // Ґодзілла, отримали цей об'єкт
 ```
 
 А ось приклад з порожнім `return` (або ми можемо розмістити примітив після нього, не має значення):
@@ -168,7 +168,7 @@ function SmallUser() {
 alert( new SmallUser().name );  // Джон
 ```
 
-Зазвичай конструктори не мають інструкції `return`. Тут ми згадуємо особливу поведінку з поверненнями об’єктів, головним чином, для повноти вивчення мови.
+Зазвичай конструктори не мають інструкції `return`. Тут ми згадуємо особливу поведінку з поверненнями об'єктів, головним чином, для повноти вивчення мови.
 
 ````smart header="Відсутність дужок"
 До речі, ми можемо опустити дужки після `new`, якщо виклик конструктора відбувається без аргументів:
@@ -184,25 +184,25 @@ let user = new User();
 
 ## Створення методів у конструкторі
 
-Використання конструкторів для створення об’єктів дає велику гнучкість. Конструктор може мати параметри, які визначають, як побудувати об’єкт і що в нього помістити.
+Використання конструкторів для створення об'єктів дає велику гнучкість. Конструктор може мати параметри, які визначають, як побудувати об'єкт і що в нього помістити.
 
 Звичайно, ми можемо додати до `this` не лише властивості, але й методи.
 
-У наведеному нижче прикладі, `new User(name)` створює об’єкт із заданим `name` та методом `sayHi`:
+У наведеному нижче прикладі, `new User(name)` створює об'єкт із заданим `name` та методом `sayHi`:
 
 ```js run
 function User(name) {
   this.name = name;
 
   this.sayHi = function() {
-    alert( "Моє ім’я: " + this.name );
+    alert( "Моє ім'я: " + this.name );
   };
 }
 
 *!*
 let john = new User("Джон");
 
-john.sayHi(); // Моє ім’я: Джон
+john.sayHi(); // Моє ім'я: Джон
 */!*
 
 /*
@@ -213,19 +213,19 @@ john = {
 */
 ```
 
-Для створення складних об’єктів існує більш просунутий синтаксис, [класи](info:classes), про який ми поговоримо пізніше.
+Для створення складних об'єктів існує більш просунутий синтаксис, [класи](info:classes), про який ми поговоримо пізніше.
 
 ## Підсумки
 
-- Функції-конструктори або, коротко, конструктори, є звичайними функціями, але існує загальна домовленість ім’я такої функції починати з великої літери.
+- Функції-конструктори або, коротко, конструктори, є звичайними функціями, але існує загальна домовленість ім'я такої функції починати з великої літери.
 - Конструктори повинні викликатися тільки з використанням оператора `new`. Такий виклик передбачає створення порожнього `this` на початку та повернення заповненого у кінці.
 
-Ми можемо використовувати конструктори для створення численних подібних об’єктів.
+Ми можемо використовувати конструктори для створення численних подібних об'єктів.
 
 JavaScript надає функції-конструктори для багатьох вбудованих об'єктів мови: наприклад, `Date`, `Set` та інших, які ми плануємо вивчати далі.
 
-```smart header="Об’єкти, ми ще до них повернемось!"
-У цьому розділі ми розглядаємо лише основи об’єктів та конструкторів. Вони є важливими для подальшого вивчення типів даних та функцій у наступних розділах.
+```smart header="Об'єкти, ми ще до них повернемось!"
+У цьому розділі ми розглядаємо лише основи об'єктів та конструкторів. Вони є важливими для подальшого вивчення типів даних та функцій у наступних розділах.
 
-Після того, як ми це вивчемо, ми повернемося до об’єктів для більш детального їх вивчення у розділах <info:prototypes> та <info:classes>.
+Після того, як ми це вивчемо, ми повернемося до об'єктів для більш детального їх вивчення у розділах <info:prototypes> та <info:classes>.
 ```
diff --git a/1-js/04-object-basics/07-optional-chaining/article.md b/1-js/04-object-basics/07-optional-chaining/article.md
index febc15464..23417fc97 100644
--- a/1-js/04-object-basics/07-optional-chaining/article.md
+++ b/1-js/04-object-basics/07-optional-chaining/article.md
@@ -3,13 +3,13 @@
 
 [recent browser="new"]
 
-Опціональний ланцюжок `?.` -- це безпечний спосіб доступу до вкладених властивостей об’єктів, навіть якщо проміжних властивостей не існує.
+Опціональний ланцюжок `?.` -- це безпечний спосіб доступу до вкладених властивостей об'єктів, навіть якщо проміжних властивостей не існує.
 
 ## Проблема "відсутньої властивості"
 
 Якщо ви тільки почали читати підручник і вивчати JavaScript, можливо ця проблема вам наразі незнайома, проте вона достатньо розповсюджена.
 
-Наприклад, розглянемо об’єкт `user` який містить інформацію про наших користувачів.
+Наприклад, розглянемо об'єкт `user` який містить інформацію про наших користувачів.
 
 В більшості наших користувачів є адреса `user.address` з вулицею `user.address.street`, проте дехто вирішив взагалі не вказувати адресу.
 
@@ -25,7 +25,7 @@ alert(user.address.street); // помилка!
 
 Проте в багатьох життєвих ситуаціях було б набагато зручніше просто отримати `undefined`, що буде означати "немає вулиці".
 
-...Ще один приклад. У веброзробці ми можемо отримати об’єкт котрий відповідає елементу на вебсторінці за допомогою спеціальних методів, наприклад: `document.querySelector('.elem')`. Проте якщо ми намагатимемось отримати елемент, якого немає на сторінці, то нам вернеться `null`.
+...Ще один приклад. У веброзробці ми можемо отримати об'єкт котрий відповідає елементу на вебсторінці за допомогою спеціальних методів, наприклад: `document.querySelector('.elem')`. Проте якщо ми намагатимемось отримати елемент, якого немає на сторінці, то нам вернеться `null`.
 
 ```js run
 // document.querySelector('.elem') рівний null якщо такого елемента не існує
@@ -44,7 +44,7 @@ let user = {};
 alert(user.address ? user.address.street : undefined);
 ```
 
-Варіант робочий, помилки не буде... Але виглядає це вкрай неелегантно. Як ви бачите `"user.address"` двічі з’являється в коді. 
+Варіант робочий, помилки не буде... Але виглядає це вкрай неелегантно. Як ви бачите `"user.address"` двічі з'являється в коді. 
 
 Ось як те ж саме виглядає для `document.querySelector`:
 
@@ -106,7 +106,7 @@ alert( user?.address?.street ); // undefined (немає помилки)
 let html = document.querySelector('.elem')?.innerHTML; // буде undefined, якщо немає елемента
 ```
 
-Читання властивості "address" з `user?.address` спрацює навіть коли в змінній `user` зберігається зовсім не об’єкт:
+Читання властивості "address" з `user?.address` спрацює навіть коли в змінній `user` зберігається зовсім не об'єкт:
 
 ```js run
 let user = null;
@@ -115,14 +115,14 @@ alert( user?.address ); // undefined
 alert( user?.address.street ); // undefined
 ```
 
-Зверніть увагу, що синтаксис `?.` робить необов’язковою тільки властивість перед ним, а не будь-яку наступну. 
+Зверніть увагу, що синтаксис `?.` робить необов'язковою тільки властивість перед ним, а не будь-яку наступну. 
 
-Наприклад в `user?.address.street.name` конструкція `user?.` дозволяє `user`  залишатись `null/undefined` (і повертати `undefined` в такому випадку), але це працює тільки для `user`. Доступ до решти властивостей здійснюється звичайним способом. Якщо ми хочемо, щоб якась з них була необов’язковою, тоді конкретно для цієї властивості нам доведеться замінити `.` на `?.`.
+Наприклад в `user?.address.street.name` конструкція `user?.` дозволяє `user`  залишатись `null/undefined` (і повертати `undefined` в такому випадку), але це працює тільки для `user`. Доступ до решти властивостей здійснюється звичайним способом. Якщо ми хочемо, щоб якась з них була необов'язковою, тоді конкретно для цієї властивості нам доведеться замінити `.` на `?.`.
 
 ````warn header="Не зловживайте опціональним ланцюжком"
 Нам слід використовувати `?.` тільки в тих ситуаціях коли ми припускаємо що значення може не існувати.
 
-Наприклад, якщо за нашою логікою об’єкт `user` точно існує, але його властивість `address` є необов’язковою, тоді нам слід використовувати конструкцію `user.address?.street`. Проте аж ніяк не `user?.address?.street`.
+Наприклад, якщо за нашою логікою об'єкт `user` точно існує, але його властивість `address` є необов'язковою, тоді нам слід використовувати конструкцію `user.address?.street`. Проте аж ніяк не `user?.address?.street`.
 
 Тоді якщо помилково змінна `user` виявиться пустою, ми побачимо програмну помилку і зможемо це виправити. В іншому випадку, якщо ми зловживаємо `?.`, помилки можуть замовчуватися там де це непотрібно й ускладнювати процес налагодження.
 ````
@@ -134,7 +134,7 @@ alert( user?.address.street ); // undefined
 // ReferenceError: user is not defined
 user?.address;
 ```
-Змінна обов’язково повинна бути оголошена (наприклад `let/const/var user` або як параметр функції). Опціональний ланцюжок працює тільки з існуючими змінними.
+Змінна обов'язково повинна бути оголошена (наприклад `let/const/var user` або як параметр функції). Опціональний ланцюжок працює тільки з існуючими змінними.
 ````
 
 ## Скорочене обчислення
@@ -180,11 +180,11 @@ userGuest.admin?.(); // нічого (немає такого методу)
 */!*
 ```
 
-В обох випадках спочатку використовуємо крапку (`userAdmin.admin`) для доступу до властивості `admin`, оскільки об’єкт користувача точно існує, а це означає що ми можемо звернутись до будь-якої його властивості.
+В обох випадках спочатку використовуємо крапку (`userAdmin.admin`) для доступу до властивості `admin`, оскільки об'єкт користувача точно існує, а це означає що ми можемо звернутись до будь-якої його властивості.
 
 Вже потім `?.()` перевіряє ліву частину: якщо функція `admin` існує, то вона виконається (у випадку з `userAdmin`). Інакше (для `userGuest`) обчислення припиниться без помилок.
 
-Також існує синтаксис `?.[]`, якщо ми хочемо отримати доступ до властивості за допомогою квадратних дужок `[]`, а не через крапку `.`. Як і в решті випадків, такий спосіб дає змогу безпечно читати властивості об’єкту яких може не існувати.
+Також існує синтаксис `?.[]`, якщо ми хочемо отримати доступ до властивості за допомогою квадратних дужок `[]`, а не через крапку `.`. Як і в решті випадків, такий спосіб дає змогу безпечно читати властивості об'єкту яких може не існувати.
 
 ```js run
 let key = "firstName";
diff --git a/1-js/04-object-basics/08-symbol/article.md b/1-js/04-object-basics/08-symbol/article.md
index ed8e248e0..18da25967 100644
--- a/1-js/04-object-basics/08-symbol/article.md
+++ b/1-js/04-object-basics/08-symbol/article.md
@@ -1,7 +1,7 @@
 
 # Тип даних Символ
 
-За специфікацією, ключами об’єкта можуть бути тільки два примітивні типи:
+За специфікацією, ключами об'єкта можуть бути тільки два примітивні типи:
 
 - тип рядок, або
 - тип символ.
@@ -22,7 +22,7 @@
 let id = Symbol();
 ```
 
-Після створення символу ми можемо надати йому опис (так званe ім’я символу), в основному це корисно для процесу налагодження:
+Після створення символу ми можемо надати йому опис (так званe ім'я символу), в основному це корисно для процесу налагодження:
 
 ```js
 // Створюємо символ id з описом (іменем) "id"
@@ -83,9 +83,9 @@ alert(id.description); // id
 ## "Приховані" властивості
 
 
-Символи дозволяють нам створювати "приховані" властивості об’єкта, до яких жодна інша частина програми не може випадково отримати доступ або перезаписати їх.
+Символи дозволяють нам створювати "приховані" властивості об'єкта, до яких жодна інша частина програми не може випадково отримати доступ або перезаписати їх.
 
-Наприклад, якщо ми працюємо з `user` об’єктами, які належать сторонньому коду. Ми хотіли б додати до них ідентифікатори.
+Наприклад, якщо ми працюємо з `user` об'єктами, які належать сторонньому коду. Ми хотіли б додати до них ідентифікатори.
 
 Використаємо для цього ключ символа:
 
@@ -103,7 +103,7 @@ alert( user[id] ); // ми можемо отримати доступ до да
 
 Яка користь від використання `Symbol("id")` замість рядка `"id"`?
 
-Оскільки об’єкт `user` належить сторонньому коду, і цей код також працює з ними, нам не варто просто додавати до нього будь-які поля. Це небезпечно. Але до символу неможливо отримати доступ випадково, сторонній код, ймовірно, навіть не побачить його, тому, додавання поля до об’єкта `user` не викличе жодних проблем.
+Оскільки об'єкт `user` належить сторонньому коду, і цей код також працює з ними, нам не варто просто додавати до нього будь-які поля. Це небезпечно. Але до символу неможливо отримати доступ випадково, сторонній код, ймовірно, навіть не побачить його, тому, додавання поля до об'єкта `user` не викличе жодних проблем.
 
 Крім того, уявіть, що інший скрипт хоче мати власний ідентифікатор всередині `user` для своїх цілей.
 
@@ -132,9 +132,9 @@ user.id = "Їхній ідентифікатор"
 // Ой! Властивість перезаписана стороннім скриптом!
 ```
 
-### Символи в літералі об’єкта
+### Символи в літералі об'єкта
 
-Якщо ми хочемо використовувати символ у літералі об’єкта `{...}`, нам потрібні обгорнути його в квадратні дужки.
+Якщо ми хочемо використовувати символ у літералі об'єкта `{...}`, нам потрібні обгорнути його в квадратні дужки.
 
 Ось так:
 
@@ -172,7 +172,7 @@ for (let key in user) alert(key); // name, age (дані ключі не є си
 alert( "Прямий доступ: " + user[id] ); // Прямий доступ: 123
 ```
 
-[Object.keys(user)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys) також ігнорує їх. Це частина загального принципу "приховування символьних властивостей". Якщо інший скрипт або бібліотека спробує перебрати наш об’єкт за допомогою цикла, він несподівано не отримає доступ до символьних властивостей.
+[Object.keys(user)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys) також ігнорує їх. Це частина загального принципу "приховування символьних властивостей". Якщо інший скрипт або бібліотека спробує перебрати наш об'єкт за допомогою цикла, він несподівано не отримає доступ до символьних властивостей.
 
 А ось, [Object.assign](mdn:js/Object/assign) копіює властивості рядка та символу:
 
@@ -187,7 +187,7 @@ let clone = Object.assign({}, user);
 alert( clone[id] ); // 123
 ```
 
-Тут немає парадокса. Саме так задумано. Ідея полягає в тому, що коли ми клонуємо об’єкт або об’єднуємо об’єкти, ми зазвичай хочемо скопіювати *всі* властивості (включаючи властивості з ключами в якості символу, як наприклад `id` з прикладу вище).
+Тут немає парадокса. Саме так задумано. Ідея полягає в тому, що коли ми клонуємо об'єкт або об'єднуємо об'єкти, ми зазвичай хочемо скопіювати *всі* властивості (включаючи властивості з ключами в якості символу, як наприклад `id` з прикладу вище).
 
 ## Глобальні символи
 
@@ -222,7 +222,7 @@ alert( id === idAgain ); // true
 
 ### Symbol.keyFor
 
-Для глобальних символів, не тільки `Symbol.for(key)` повертає символ за іменем, також існує протилежний метод: `Symbol.keyFor(sym)`, який працює навпаки: приймає глобальний символ і повертає його ім’я.
+Для глобальних символів, не тільки `Symbol.for(key)` повертає символ за іменем, також існує протилежний метод: `Symbol.keyFor(sym)`, який працює навпаки: приймає глобальний символ і повертає його ім'я.
 
 Наприклад:
 
@@ -231,7 +231,7 @@ alert( id === idAgain ); // true
 let sym = Symbol.for("name");
 let sym2 = Symbol.for("id");
 
-// отримуємо ім’я за символом
+// отримуємо ім'я за символом
 alert( Symbol.keyFor(sym) ); // name
 alert( Symbol.keyFor(sym2) ); // id
 ```
@@ -254,7 +254,7 @@ alert( localSymbol.description ); // name
 
 ## Системні символи
 
-Існує багато “системних” символів, які JavaScript використовує внутрішньо, і ми можемо використовувати їх для налаштування різних аспектів наших об’єктів.
+Існує багато “системних” символів, які JavaScript використовує внутрішньо, і ми можемо використовувати їх для налаштування різних аспектів наших об'єктів.
 
 Вони вказані в таблиці специфікації [Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols):
 
@@ -264,7 +264,7 @@ alert( localSymbol.description ); // name
 - `Symbol.toPrimitive`
 - ...та інші.
 
-До прикладу, `Symbol.toPrimitive` дозволяє описати  правила для об’єкта до примітивного перетворення. Ми побачимо його використання дуже скоро.
+До прикладу, `Symbol.toPrimitive` дозволяє описати  правила для об'єкта до примітивного перетворення. Ми побачимо його використання дуже скоро.
 
 З іншими системними символами познайомимось ближче, коли ми будемо вивчати відповідні мовні особливості.
 
@@ -272,18 +272,18 @@ alert( localSymbol.description ); // name
 
 `Symbol` -- це примітивний тип даних який використовується для унікальних ідентифікаторів.
 
-Символ створюється за допомогою виклику `Symbol()` з необов’язковим описом (ім’я).
+Символ створюється за допомогою виклику `Symbol()` з необов'язковим описом (ім'я).
 
 Символи -- завжди унікальні, навіть якщо вони мають однакову назву. Якщо ми хочемо, щоб однойменні символи були рівними за значенням, тоді слід використовувати глобальний реєстр: `Symbol.for(key)` повертає (створює за потреби) глобальний символ з `key` в якості імені. Декілька викликів `Symbol.for` з тією ж `key` повертає той самий символ.
 
 Символи мають два основних варіанти використання:
 
-1. "Приховані" властивості об’єкта.
+1. "Приховані" властивості об'єкта.
     
-    Якщо ми хочемо додати властивість до об’єкта, який "належить" іншому скрипту або бібліотеці, ми можемо створити символ і використовувати його як ключ. Властивість у вигляді символу не відображається в `for..in`, тому вона не буде випадково оброблена разом з іншими властивостями. Крім того, він не буде безпосередньо доступний, оскільки інший скрипт не має нашого символу. Таким чином властивість буде захищена від випадкового використання або перезапису.
+    Якщо ми хочемо додати властивість до об'єкта, який "належить" іншому скрипту або бібліотеці, ми можемо створити символ і використовувати його як ключ. Властивість у вигляді символу не відображається в `for..in`, тому вона не буде випадково оброблена разом з іншими властивостями. Крім того, він не буде безпосередньо доступний, оскільки інший скрипт не має нашого символу. Таким чином властивість буде захищена від випадкового використання або перезапису.
 
-    Тож ми можемо ховати щось потрібне для нас в об’єкти, що сторонні не повинні бачити, використовуючи символічні властивості.
+    Тож ми можемо ховати щось потрібне для нас в об'єкти, що сторонні не повинні бачити, використовуючи символічні властивості.
 
-2. JavaScript використовує багато системних символів, доступних як `Symbol.*`. Ми можемо використовувати їх для зміни деяких вбудованих форм поведінки. До прикладу, пізніше в посібнику ми будемо використовувати `Symbol.iterator` для [ітераторів](info:iterable), `Symbol.toPrimitive` для налаштування [перетворення об’єкта в примітив](info:object-toprimitive) тощо.
+2. JavaScript використовує багато системних символів, доступних як `Symbol.*`. Ми можемо використовувати їх для зміни деяких вбудованих форм поведінки. До прикладу, пізніше в посібнику ми будемо використовувати `Symbol.iterator` для [ітераторів](info:iterable), `Symbol.toPrimitive` для налаштування [перетворення об'єкта в примітив](info:object-toprimitive) тощо.
 
-Технічно символи не приховані на 100%. Існує вбудований метод [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) що дозволяє отримати всі символи. Також існує метод з іменем [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) що повертає *всі* ключі об’єкта, включаючи символьні. Тож вони насправді не зовсім приховані. Але більшість бібліотек, вбудованих функцій та конструкцій синтаксису не використовують ці методи.
+Технічно символи не приховані на 100%. Існує вбудований метод [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) що дозволяє отримати всі символи. Також існує метод з іменем [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) що повертає *всі* ключі об'єкта, включаючи символьні. Тож вони насправді не зовсім приховані. Але більшість бібліотек, вбудованих функцій та конструкцій синтаксису не використовують ці методи.
diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 255fa659f..0d269efac 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -1,34 +1,34 @@
 
-# Перетворення об’єктів в примітиви
+# Перетворення об'єктів в примітиви
 
-Що відбувається, коли об’єкти додаються `obj1 + obj2`, віднімаються `obj1 - obj2` або друкуються за допомогою `alert(obj)`?
+Що відбувається, коли об'єкти додаються `obj1 + obj2`, віднімаються `obj1 - obj2` або друкуються за допомогою `alert(obj)`?
 
-JavaScript не дозволяє налаштувати, як працюють оператори з об’єктами. На відміну від деяких інших мов програмування, таких як Ruby або C++, ми не можемо реалізувати спеціальний об’єктний метод для обробки додавання (або інших операторів).
+JavaScript не дозволяє налаштувати, як працюють оператори з об'єктами. На відміну від деяких інших мов програмування, таких як Ruby або C++, ми не можемо реалізувати спеціальний об'єктний метод для обробки додавання (або інших операторів).
 
-У разі таких операцій об’єкти автоматично перетворюються на примітиви, а потім операція здійснюється над цими примітивами та повертає результат у вигляді примітивного значення.
+У разі таких операцій об'єкти автоматично перетворюються на примітиви, а потім операція здійснюється над цими примітивами та повертає результат у вигляді примітивного значення.
 
-Це важливе обмеження, оскільки результат `obj1 + obj2` (або інша математична операція) не може бути іншим об’єктом!
+Це важливе обмеження, оскільки результат `obj1 + obj2` (або інша математична операція) не може бути іншим об'єктом!
 
-Наприклад, ми не можемо зробити об’єкти, що представляють вектори або матриці (або досягнення або що завгодно) та додати їх і очікувати, що "підсумковий" результат буде об’єктом. Автоматично такі архітектурні особливості недоступні.
+Наприклад, ми не можемо зробити об'єкти, що представляють вектори або матриці (або досягнення або що завгодно) та додати їх і очікувати, що "підсумковий" результат буде об'єктом. Автоматично такі архітектурні особливості недоступні.
 
-Отже, оскільки ми не можемо автоматично за допомогою мови програмування виконувати подібні операції над об’єктами, то в реальних проєктах немає "математики з об’єктами". Коли подібні операції все ж таки відбуваються, причиною цьому зазвичай є помилка програмування.
+Отже, оскільки ми не можемо автоматично за допомогою мови програмування виконувати подібні операції над об'єктами, то в реальних проєктах немає "математики з об'єктами". Коли подібні операції все ж таки відбуваються, причиною цьому зазвичай є помилка програмування.
 
-У цьому розділі ми розглянемо те, як об’єкти перетворюється на примітиви і як налаштувати це.
+У цьому розділі ми розглянемо те, як об'єкти перетворюється на примітиви і як налаштувати це.
 
 У нас є два цілі:
 
 1. Це дозволить нам зрозуміти, що відбувається у випадку помилок коду, коли така операція відбулася випадково.
-2. Є винятки, де такі операції можливі і доцільні. Наприклад, віднімання або порівняння дати (`Date` об’єкти). Ми будемо зустрічатися з ними пізніше.
+2. Є винятки, де такі операції можливі і доцільні. Наприклад, віднімання або порівняння дати (`Date` об'єкти). Ми будемо зустрічатися з ними пізніше.
 
 ## Правила перетворення
 
-У розділі <info:type-conversions> ми бачили правила для перетворення чисел, рядків та булевих примітивів. Але ми залишили пробіл для об’єктів. Тепер, оскільки ми знаємо про методи та символи, можемо заповнити його.
+У розділі <info:type-conversions> ми бачили правила для перетворення чисел, рядків та булевих примітивів. Але ми залишили пробіл для об'єктів. Тепер, оскільки ми знаємо про методи та символи, можемо заповнити його.
 
-1. Всі об’єкти -- це `true` в булевому контексті. Є лише числові та рядкові конверсії.
-2. Числове перетворення відбувається, коли ми віднімаємо об’єкти або застосовуємо математичні функції. Наприклад, `Date` об’єкти (розглянуті в розділі <info:date>) можуть відніматися, і результат `date1 - date2` -- це різниця у часі між двома датами.
-3. Що стосується перетворення рядків -- це зазвичай відбувається, коли ми виводимо об’єкт, наприклад `alert(obj)` і в подібних контекстах.
+1. Всі об'єкти -- це `true` в булевому контексті. Є лише числові та рядкові конверсії.
+2. Числове перетворення відбувається, коли ми віднімаємо об'єкти або застосовуємо математичні функції. Наприклад, `Date` об'єкти (розглянуті в розділі <info:date>) можуть відніматися, і результат `date1 - date2` -- це різниця у часі між двома датами.
+3. Що стосується перетворення рядків -- це зазвичай відбувається, коли ми виводимо об'єкт, наприклад `alert(obj)` і в подібних контекстах.
 
-Ми можемо точно налагоджувати перетворення рядків та чисел, використовуючи спеціальні методи об’єкта.
+Ми можемо точно налагоджувати перетворення рядків та чисел, використовуючи спеціальні методи об'єкта.
 
 Тепер перейдемо до технічних деталей, бо це єдиний спосіб детально висвітити тему.
 
@@ -39,18 +39,18 @@ JavaScript не дозволяє налаштувати, як працюють 
 Є три варіанти перетворення типів, що відбуваються в різних ситуаціях. Вони називаються "підказками" ("hints"), і описані в [специфікації](https://tc39.github.io/ecma262/#sec-toprimitive):
 
 `"string"`
-: Перетворення об’єкта в рядок відбувається коли ми виконуємо операцію, яка очікує рядок, над об’єктом. Наприклад, `alert`:
+: Перетворення об'єкта в рядок відбувається коли ми виконуємо операцію, яка очікує рядок, над об'єктом. Наприклад, `alert`:
 
     ```js
     // вивід
     alert(obj);
 
-    // використання об’єкта як ключа властивості об’єкта
+    // використання об'єкта як ключа властивості об'єкта
     anotherObj[obj] = 123;
     ```
 
 `"number"`
-: Перетворення об’єкта в число, коли ми робимо математичні операції:
+: Перетворення об'єкта в число, коли ми робимо математичні операції:
 
     ```js
     // явне перетворення
@@ -69,9 +69,9 @@ JavaScript не дозволяє налаштувати, як працюють 
 `"default"`
 : Виникає в рідкісних випадках, коли оператор "не впевнений", який тип очікується.
 
-    Наприклад, бінарний плюс `+` може працювати як з рядками (об’єднувати їх), так і з цифрами (додавати їх), тому обидва випадки -- рядки та цифри -- будуть працювати. Отже, якщо бінарний плюс отримує об’єкт як аргумент, він використовує підказку `"default"`, щоб перетворити його.
+    Наприклад, бінарний плюс `+` може працювати як з рядками (об'єднувати їх), так і з цифрами (додавати їх), тому обидва випадки -- рядки та цифри -- будуть працювати. Отже, якщо бінарний плюс отримує об'єкт як аргумент, він використовує підказку `"default"`, щоб перетворити його.
 
-    Також, якщо об’єкт порівнюється (`==`) з рядком, числом чи символом, тоді незрозуміло, яке порівняння використати, тому використовується підказка `"default"`.
+    Також, якщо об'єкт порівнюється (`==`) з рядком, числом чи символом, тоді незрозуміло, яке порівняння використати, тому використовується підказка `"default"`.
 
     ```js
     // бінарний плюс використовує підказку "default"
@@ -85,11 +85,11 @@ JavaScript не дозволяє налаштувати, як працюють 
 
 Але на практиці все трохи простіше.
     
-Всі вбудовані об’єкти, крім одного випадку (об’єкт `Date`, ми дізнаємося пізніше) реалізовують `"default"` перетворення так само, як `"number"`. І ми можемо зробити те ж саме.
+Всі вбудовані об'єкти, крім одного випадку (об'єкт `Date`, ми дізнаємося пізніше) реалізовують `"default"` перетворення так само, як `"number"`. І ми можемо зробити те ж саме.
 
 Проте важливо знати про всі три підказки, незабаром ми побачимо, чому.
 
-** Щоб зробити перетворення, JavaScript намагається знайти та викликати три методи об’єкта: **
+** Щоб зробити перетворення, JavaScript намагається знайти та викликати три методи об'єкта: **
 
 1. Викликати `obj[Symbol.toPrimitive](hint)` -- метод з символьним ключем `Symbol.toPrimitive` (системний символ), якщо такий метод існує,
 2. Інакше, якщо підказка - це `"string"`
@@ -103,7 +103,7 @@ JavaScript не дозволяє налаштувати, як працюють 
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
-  // тут йде код, щоб перетворити цей об’єкт в примітив
+  // тут йде код, щоб перетворити цей об'єкт в примітив
   // він повинен повернути примітивне значення
   // hint = один з "string", "number", "default"
 };
@@ -111,7 +111,7 @@ obj[Symbol.toPrimitive] = function(hint) {
 
 Якщо метод `symbol.toprimitive` існує, він використовується для всіх підказок, і не потрібно більше методів.
 
-Наприклад, тут об’єкт `user` реалізує його:
+Наприклад, тут об'єкт `user` реалізує його:
 
 ```js run
 let user = {
@@ -130,7 +130,7 @@ alert(+user); // hint: number -> 1000
 alert(user + 500); // hint: default -> 1500
 ```
 
-Як ми бачимо з коду, `user` стає самоописаним рядком або грошовою сумою залежно від перетворення. Єдиний метод `[Symbol.toPrimitive]` об’єкту `user` обробляє всі випадки перетворення.
+Як ми бачимо з коду, `user` стає самоописаним рядком або грошовою сумою залежно від перетворення. Єдиний метод `[Symbol.toPrimitive]` об'єкту `user` обробляє всі випадки перетворення.
 
 ## toString/valueOf
 
@@ -141,12 +141,12 @@ alert(user + 500); // hint: default -> 1500
 
 Методи `toString` і `valueOf` походять з давніх часів. Вони не є символами (багато часу назад символи не існували), а скоріше є "звичними" методами, що названі за допомогою рядків. Вони забезпечують альтернативний шлях "старого стилю" для реалізації перетворення.
 
-Ці методи повинні повертати примітивне значення. Якщо `toString` чи `valueOf` повертає об’єкт, то він ігнорується (так само, якби цього методу не існувало).
+Ці методи повинні повертати примітивне значення. Якщо `toString` чи `valueOf` повертає об'єкт, то він ігнорується (так само, якби цього методу не існувало).
 
-За замовчуванням, простий об’єкт має слідувати методами `toString` та `valueOf`:
+За замовчуванням, простий об'єкт має слідувати методами `toString` та `valueOf`:
 
 - Метод `toString` повертає рядок `"[object Object]"`.
-- Метод `valueOf` повертає сам об’єкт.
+- Метод `valueOf` повертає сам об'єкт.
 
 Ось демо:
 
@@ -157,9 +157,9 @@ alert(user); // [object Object]
 alert(user.valueOf() === user); // true
 ```
 
-Отже, якщо ми спробуємо використовувати об’єкт як рядок, наприклад в `alert` та ін., то за замовчуванням ми бачимо `[object Object]`.
+Отже, якщо ми спробуємо використовувати об'єкт як рядок, наприклад в `alert` та ін., то за замовчуванням ми бачимо `[object Object]`.
 
-За замовчуванням метод `valueOf` згадується тут лише заради повноти, щоб уникнути будь-якої плутанини. Як ви бачите, він повертає сам об’єкт, і тому ігнорується. Не питайте мене, чому це для історичних причин. Тому ми можемо припустити, що цього не існує.
+За замовчуванням метод `valueOf` згадується тут лише заради повноти, щоб уникнути будь-якої плутанини. Як ви бачите, він повертає сам об'єкт, і тому ігнорується. Не питайте мене, чому це для історичних причин. Тому ми можемо припустити, що цього не існує.
 
 Реалізуємо ці методи для налаштування перетворення.
 
@@ -208,14 +208,14 @@ alert(user + 500); // toString -> Іван500
 
 ### Перетворення може повернути будь-який примітивний тип
 
-Важливо знати про всі методи примітивні перетворення те, що вони не обов’язково повертають "підказаний" примітив.
+Важливо знати про всі методи примітивні перетворення те, що вони не обов'язково повертають "підказаний" примітив.
 
 Немає контролю, чи повертає `toString` саме рядок, або чи `symbol.toprimitive` метод повертає номер для підказки `"number"`.
 
-Єдина обов’язкова річ: ці методи повинні повертати примітивний тип, а не об’єкт.
+Єдина обов'язкова річ: ці методи повинні повертати примітивний тип, а не об'єкт.
 
 ```smart header="Історичні нотатки"
-З історичних причин, якщо `toString` чи `valueOf` повертає об’єкт. В цьому немає помилки, але таке значення ігнорується (так само, якби цей метод не існував). Це тому, що в давнину в JavaScript не було хорошого концепту "помилка".
+З історичних причин, якщо `toString` чи `valueOf` повертає об'єкт. В цьому немає помилки, але таке значення ігнорується (так само, якби цей метод не існував). Це тому, що в давнину в JavaScript не було хорошого концепту "помилка".
 
 Навпаки, `Symbol.toPrimitive` *повинен* повернути примітив, інакше буде помилка.
 ```
@@ -224,8 +224,8 @@ alert(user + 500); // toString -> Іван500
 
 Як ми вже знаємо, багато операторів та функцій виконують перетворення типу, наприклад, множення `*` перетворює операнди в цифри.
 
-Якщо ми передамо об’єкт як аргумент, то є два етапи:
-1. Об’єкт перетворюється на примітив (використовуючи правила, описані вище).
+Якщо ми передамо об'єкт як аргумент, то є два етапи:
+1. Об'єкт перетворюється на примітив (використовуючи правила, описані вище).
 2. Якщо отриманий примітив не є правильним типом, він перетворюється.
 
 Наприклад:
@@ -238,13 +238,13 @@ let obj = {
   }
 };
 
-alert(obj * 2); // 4, об’єкт перетворився на примітив "2", потім множення зробило це числом
+alert(obj * 2); // 4, об'єкт перетворився на примітив "2", потім множення зробило це числом
 ```
 
-1. Множення `obj * 2` спочатку перетворює об’єкт в примітив (це рядок `"2"`).
+1. Множення `obj * 2` спочатку перетворює об'єкт в примітив (це рядок `"2"`).
 2. Тоді `"2" * 2` стає `2 * 2` (рядок перетворюється на номер).
 
-Бінарний плюс буде об’єднувати рядки в такій же ситуації, оскільки він приймає рядки:
+Бінарний плюс буде об'єднувати рядки в такій же ситуації, оскільки він приймає рядки:
 
 ```js run
 let obj = {
@@ -258,12 +258,12 @@ alert(obj + 2); // 22 ("2" + 2), перетворення до примітив
 
 ## Підсумки
 
-Об’єктно-примітивне перетворення викликається автоматично багатьма вбудованими функціями та операторами, які очікують примітиву як значення.
+Об'єктно-примітивне перетворення викликається автоматично багатьма вбудованими функціями та операторами, які очікують примітиву як значення.
 
 Є 3 типи (підказки) цього:
 - `"string"` (для `alert` та інших операцій, які потребують рядка)
 - `"number"` (для математичних операцій)
-- `"default"` (кілька операторів, зазвичай об’єкти реалізують це так само, як і `"number"`.)
+- `"default"` (кілька операторів, зазвичай об'єкти реалізують це так само, як і `"number"`.)
 
 Специфікація явно описує, який оператор використовує яку підказку.
 
@@ -277,4 +277,4 @@ alert(obj + 2); // 22 ("2" + 2), перетворення до примітив
 
 Усі ці методи повинні повернути примітив до роботи (якщо визначені).
 
-На практиці досить часто для реалізації достатньо лише `obj.toString()` як універсального методу для перетворення рядків, який повинен повернути "читабельне для людини" представлення об’єкта, для цілей логування або пошуку помилок.
+На практиці досить часто для реалізації достатньо лише `obj.toString()` як універсального методу для перетворення рядків, який повинен повернути "читабельне для людини" представлення об'єкта, для цілей логування або пошуку помилок.
diff --git a/1-js/04-object-basics/index.md b/1-js/04-object-basics/index.md
index 0fe95d0bf..149010537 100644
--- a/1-js/04-object-basics/index.md
+++ b/1-js/04-object-basics/index.md
@@ -1 +1 @@
-# Об’єкти: основи
+# Об'єкти: основи
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index 19281c3c7..cd59b608f 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -1,20 +1,20 @@
 # Методи примітивів
  
-JavaScript дозволяє працювати з примітивами (рядок, число, тощо) так само як з об’єктами. Вони також надають методи для роботи. Ми вивчимо їх найближчим часом, але спочатку подивимось як воно працює, тому що примітиви не є об’єктами (і тут ми зробимо це ще більш зрозумілим).
+JavaScript дозволяє працювати з примітивами (рядок, число, тощо) так само як з об'єктами. Вони також надають методи для роботи. Ми вивчимо їх найближчим часом, але спочатку подивимось як воно працює, тому що примітиви не є об'єктами (і тут ми зробимо це ще більш зрозумілим).
 
-Розгляньмо різницю між примітивами та об’єктами.
+Розгляньмо різницю між примітивами та об'єктами.
 
 Примітив
 
 - є значенням примітивного типу
 - існує 7 типів примітивів: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` та `undefined`.
 
-Об’єкт
+Об'єкт
 
 - можна зберігати декілька значень як властивості.
-- може бути створений за допомогою `{}`, наприклад: `{name: "Іван", age: 30}`. В JavaScript існують й інші об’єкти: функції — це теж об’єкти.
+- може бути створений за допомогою `{}`, наприклад: `{name: "Іван", age: 30}`. В JavaScript існують й інші об'єкти: функції — це теж об'єкти.
 
-Одна з цікавих речей щодо об’єктів полягає в тому, що ми можемо зберігати функцію як одну з його властивостей.
+Одна з цікавих речей щодо об'єктів полягає в тому, що ми можемо зберігати функцію як одну з його властивостей.
 
 ```js run
 let john = {
@@ -27,15 +27,15 @@ let john = {
 john.sayHi(); // Привіт, друже!
 ```
 
-Отже, ми створили об’єкт `john` з методом `sayHi`.
+Отже, ми створили об'єкт `john` з методом `sayHi`.
 
-Вже існує багато вбудованих об’єктів, які працюють з датами, помилками, елементами HTML і т.д. Вони мають різні властивості і методи.
+Вже існує багато вбудованих об'єктів, які працюють з датами, помилками, елементами HTML і т.д. Вони мають різні властивості і методи.
 
 Але за все потрібно платити!
 
-Об’єкти "важчі", ніж примітиви. Вони вимагають додаткових ресурсів для підтримки внутрішньої обробки.
+Об'єкти "важчі", ніж примітиви. Вони вимагають додаткових ресурсів для підтримки внутрішньої обробки.
 
-## Примітив як об’єкт
+## Примітив як об'єкт
 
 Маємо парадокс, з яким зустрічається автор JavaScript:
 
@@ -46,7 +46,7 @@ john.sayHi(); // Привіт, друже!
 
 1. Примітиви залишаються примітивами. Лише значення, як ви і хотіли.
 2. JavaScript дозволяє отримати доступ до методів та властивостей рядків, чисел, булеанів та символів.
-3. Для цього створюється спеціальний "об’єкт обгортка" з додатковою функціональністю, який потім знищується.
+3. Для цього створюється спеціальний "об'єкт обгортка" з додатковою функціональністю, який потім знищується.
 
 Для кожного примітиву створюється своя "обгортка": `String`, `Number`, `Boolean`, `Symbol` та `BigInt`. Отже, вони містять різні набори методів.
 
@@ -62,13 +62,13 @@ alert( str.toUpperCase() ); // ПРИВІТ
 
 Не складно, так? Ось що саме трапляється в `str.toUpperCase()`:
 
-1. Рядок `str` є примітивом. Тому під час звернення до його властивості створюється спеціальний об’єкт, який знає значення рядка і має корисні методи, такі як `toUpperCase()`.
+1. Рядок `str` є примітивом. Тому під час звернення до його властивості створюється спеціальний об'єкт, який знає значення рядка і має корисні методи, такі як `toUpperCase()`.
 2. Цей метод виконується і повертає новий рядок (що показує `alert`).
-3. Спеціальний об’єкт руйнується, залишаючи лише примітив `str`.
+3. Спеціальний об'єкт руйнується, залишаючи лише примітив `str`.
 
 Отже, примітиви можуть надавати методи, але залишаються "легкими".
 
-Двигун JavaScript добре оптимізує цей процес. Він навіть може пропустити створення додаткового об’єкта взагалі. Але він все ще повинен дотримуватися специфікації і вести себе так, наче він її створює.
+Двигун JavaScript добре оптимізує цей процес. Він навіть може пропустити створення додаткового об'єкта взагалі. Але він все ще повинен дотримуватися специфікації і вести себе так, наче він її створює.
 
 Число має свої методи, наприклад: [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) - округлює число до заданої точності:
 
@@ -82,7 +82,7 @@ alert( n.toFixed(2) ); // 1.23
 
 
 ````warn header="Конструктори `String/Number/Boolean` лише для внутрішнього використання"
-Деякі мови як Java дозволяють явно створювати "об’єкт обгортку" для примітивів, використовуючи синтаксис як `new Number(1)` або `new Boolean(false)`.
+Деякі мови як Java дозволяють явно створювати "об'єкт обгортку" для примітивів, використовуючи синтаксис як `new Number(1)` або `new Boolean(false)`.
 
 У JavaScript це також можливо з історичних причин, але надзвичайно **не рекомендується**. Це призведе до непередбачуваних речей.
 
@@ -94,12 +94,12 @@ alert( typeof 0 ); // "number"
 alert( typeof new Number(0) ); // "object"!
 ```
 
-Об’єкти завжди повертають `true` в `if`, отже ми побачимо `alert`:
+Об'єкти завжди повертають `true` в `if`, отже ми побачимо `alert`:
 
 ```js run
 let zero = new Number(0);
 
-if (zero) { // zero є true, тому що це об’єкт
+if (zero) { // zero є true, тому що це об'єкт
   alert( "zero є true!?!" );
 }
 ```
@@ -115,7 +115,7 @@ let num = Number("123"); // конвертує рядок в число
 
 
 ````warn header="null/undefined не мають методів" 
-Винятки становлять спеціальні примітиви `null` і `undefined`. Вони не мають відповідних "об’єктів обгорток" і не надають ніяких методів. Ми можемо назвати їх "найпримітивнішими".
+Винятки становлять спеціальні примітиви `null` і `undefined`. Вони не мають відповідних "об'єктів обгорток" і не надають ніяких методів. Ми можемо назвати їх "найпримітивнішими".
 
 Спроба доступу до властивості такого значення дасть помилку:
 
@@ -126,4 +126,4 @@ alert(null.test); // помилка
 ## Підсумки
 
 - Примітиви, крім `null` і `undefined`, дають багато корисних методів. Ми вивчимо їх у наступних розділах.
-- Формально, ці методи працюють через тимчасові об’єкти, але двигун JavaScript оптимізовано для швидкого виконання цих операцій, тому нам не треба хвилюватися.
+- Формально, ці методи працюють через тимчасові об'єкти, але двигун JavaScript оптимізовано для швидкого виконання цих операцій, тому нам не треба хвилюватися.
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
index 0edf54c4f..8ba8651af 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
@@ -13,7 +13,7 @@ alert( randomInteger(1, 3) );
 
 Функція працює, але вона неправильна. Ймовірність отримати граничні значення `min` і `max` в два рази менше, ніж будь-які інші.
 
-Якщо ви запускаєте приклад вище, багато разів, ви легко побачите, що `2` з’являється найчастіше.
+Якщо ви запускаєте приклад вище, багато разів, ви легко побачите, що `2` з'являється найчастіше.
 
 Це відбувається тому, що `Math.round()` отримує випадкові числа з інтервалу `1..3` і округляє їх так:
 
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index ed7f9a8be..8217befe8 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -55,7 +55,7 @@ let mcs = 1e-6; // шість нулів зліва від 1
 
 Якщо порахувати нулі в `0.000001`, їх буде 6. Так що, цілком очікувано, що це `1e-6`.
 
-Іншими словами, від’ємне число після `"е"` означає ділення на 1 з заданою кількістю нулів:
+Іншими словами, від'ємне число після `"е"` означає ділення на 1 з заданою кількістю нулів:
 
 ```js
 // -3 ділиться на 1 з 3 нулями
@@ -220,7 +220,7 @@ alert( 0.1 + 0.2 ); // 0.30000000000000004
 
 Але чому так відбувається?
 
-Число зберігається в пам’яті у його двійковій формі, послідовність бітів - одиниць і нулів. Але дроби на кшталт `0.1`, `0.2`, які виглядають просто в десятковій системі числення, насправді є нескінченними дробами у своїй двійковій формі.
+Число зберігається в пам'яті у його двійковій формі, послідовність бітів - одиниць і нулів. Але дроби на кшталт `0.1`, `0.2`, які виглядають просто в десятковій системі числення, насправді є нескінченними дробами у своїй двійковій формі.
 
 Іншими словами, що таке `0.1`? Це одиниця розділена на десять `1/10` -- одна десята. У десятковій системі такі числа досить легко представити, але якщо порівняти його з однією третиною: `1/3`, то ми стикаємось з нескінченним дробом `0.33333(3)`.
 
@@ -293,7 +293,7 @@ JavaScript не викликає помилку в таких випадках.
 
 ## Перевірки: isFinite та isNaN
 
-Пам’ятаєте ці два особливі числові значення?
+Пам'ятаєте ці два особливі числові значення?
 
 - `Infinity` (та `-Infinity`) - це особливе числове значення, яке більше (менше) ніж усе.
 - `NaN` представляє помилку.
@@ -406,7 +406,7 @@ alert( parseInt('a123') ); // NaN, перший символ зупиняє пр
 ```
 
 ````smart header="Другий аргумент `parseInt(str, radix)`"
-Функція `parseInt()` має необов’язковий другий аргумент. Він вказує основу системи числення, тому `parseInt` також може проаналізувати рядки шістнадцяткових, двійкових та інших чисел:
+Функція `parseInt()` має необов'язковий другий аргумент. Він вказує основу системи числення, тому `parseInt` також може проаналізувати рядки шістнадцяткових, двійкових та інших чисел:
 
 ```js run
 alert( parseInt('0xff', 16) ); // 255
@@ -418,7 +418,7 @@ alert( parseInt('2n9c', 36) ); // 123456
 
 ## Інші математичні функції
 
-JavaScript має вбудований [Math](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math) об’єкт, який містить невелику бібліотеку математичних функцій та констант.
+JavaScript має вбудований [Math](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math) об'єкт, який містить невелику бібліотеку математичних функцій та констант.
 
 Декілька прикладів:
 
@@ -446,14 +446,14 @@ JavaScript має вбудований [Math](https://developer.mozilla.org/uk/d
     alert( Math.pow(2, 10) ); // 2 у ступені 10 = 1024
     ```
 
-Об’єкт `Math` включає ще багато функцій і констант, в тому числі тригонометрію. Детальніше про об’єкт `Math` можна почитати в [документації](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math).
+Об'єкт `Math` включає ще багато функцій і констант, в тому числі тригонометрію. Детальніше про об'єкт `Math` можна почитати в [документації](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math).
 
 ## Підсумки
 
 Щоб записати числа з багатьма нулями:
 
 - Додайте `"e"` з числом нулів до числа. Як і: `123e6` те саме, що `123` з 6 нулями `123000000`.
-- Від’ємне число після `"е"` призводить до ділення числа на 1 із заданими нулями. Наприклад `123e-6` означає `0.000123` (`123` мільйони).
+- Від'ємне число після `"е"` призводить до ділення числа на 1 із заданими нулями. Наприклад `123e-6` означає `0.000123` (`123` мільйони).
 
 Для різних систем числення:
 
@@ -475,8 +475,8 @@ JavaScript має вбудований [Math](https://developer.mozilla.org/uk/d
 Для дробів:
 
 - Округлюйте за допомогою `Math.floor`, `Math.ceil`, `Math.trunc`, `Math.round` або `num.toFixed(precision)`.
-- Пам’ятайте, що при роботі з дробами втрачається точність.
+- Пам'ятайте, що при роботі з дробами втрачається точність.
 
 Більше математичних функцій:
 
-- Дивіться об’єкт [Math](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math), коли вони вам потрібні. Бібліотека дуже мала, але охоплює основні потреби.
+- Дивіться об'єкт [Math](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Math), коли вони вам потрібні. Бібліотека дуже мала, але охоплює основні потреби.
diff --git a/1-js/05-data-types/04-array/1-item-value/solution.md b/1-js/05-data-types/04-array/1-item-value/solution.md
index f70732314..f59209136 100644
--- a/1-js/05-data-types/04-array/1-item-value/solution.md
+++ b/1-js/05-data-types/04-array/1-item-value/solution.md
@@ -13,4 +13,4 @@ alert( fruits.length ); // 4
 */!*
 ```
 
-Це відбувається тому, що масиви — це об’єкти. Отже, `shoppingCart` та `fruits` посилаються на один і той самий об’єкт.
+Це відбувається тому, що масиви — це об'єкти. Отже, `shoppingCart` та `fruits` посилаються на один і той самий об'єкт.
diff --git a/1-js/05-data-types/04-array/3-call-array-this/solution.md b/1-js/05-data-types/04-array/3-call-array-this/solution.md
index 17b7c0c02..379a6ffcb 100644
--- a/1-js/05-data-types/04-array/3-call-array-this/solution.md
+++ b/1-js/05-data-types/04-array/3-call-array-this/solution.md
@@ -1,6 +1,6 @@
 Виклик `arr[2]()` це - синтаксично старий-добрий `obj[method]()`, в ролі `obj` ми маємо `arr`, а в ролі `method` ми маємо `2`.
 
-Ми маємо виклик функції `arr[2]` як методу об’єкту. Відповідно, він отримає в якості `this` об’єкт `arr` та виведе масив:
+Ми маємо виклик функції `arr[2]` як методу об'єкту. Відповідно, він отримає в якості `this` об'єкт `arr` та виведе масив:
 
 ```js run
 let arr = ["a", "b"];
diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
index a6e182105..ce8aea51e 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -1,10 +1,10 @@
 # Масиви
 
-Об’єкти дозволяють зберігати набори значень з ключами. Це чудово.
+Об'єкти дозволяють зберігати набори значень з ключами. Це чудово.
 
 Але досить часто ми розуміємо, що нам необхідна впорядкована колекція даних, яка складається з 1-го, 2-го, 3-го і т.д. елементів. Наприклад, така колеція може знадобитись для зберігання списку користувачів, товарів, HTML елементів та ін.
 
-Використовувати об’єкти в такому випадку не зручно, тому що вони не надають методів управління порядком елементів. Ми не можемо вставити нову властивість "між" існуючих. Об’єкти просто не призначені для цього.
+Використовувати об'єкти в такому випадку не зручно, тому що вони не надають методів управління порядком елементів. Ми не можемо вставити нову властивість "між" існуючих. Об'єкти просто не призначені для цього.
 
 Для зберігання впорядкованих колекцій існує інший тип даних, який має назву масив, `Array`.
 
@@ -71,7 +71,7 @@ alert( fruits ); // Apple,Orange,Plum
 // різні типи значень
 let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ];
 
-// отримати елемент з індексом 1 (об’єкт) та вивести його властивість name
+// отримати елемент з індексом 1 (об'єкт) та вивести його властивість name
 alert( arr[1].name ); // John
 
 // отримати елемент з індексом 3 (функція) та виконати її
@@ -80,7 +80,7 @@ arr[3](); // hello
 
 
 ````smart header="Кома в кінці"
-Список елементів масиву, як і список елементів об’єкту може закінчуватись комою:
+Список елементів масиву, як і список елементів об'єкту може закінчуватись комою:
 ```js
 let fruits = [
   "Apple",
@@ -110,7 +110,7 @@ let fruits = ["Apple", "Orange", "Plum"];
 alert( fruits[fruits.length-1] ); // Plum
 ```
 
-Трохи громіздко, чи не так? Нам потрібно двічі написати ім’я змінної.
+Трохи громіздко, чи не так? Нам потрібно двічі написати ім'я змінної.
 
 На щастя, є коротший синтаксис: `fruits.at(-1)`:
 
@@ -127,7 +127,7 @@ alert( fruits.at(-1) ); // Plum
 
 ## Методи pop/push, shift/unshift
 
-[Черга](https://uk.wikipedia.org/wiki/Черга_(структура_даних)) — один з найбільш популярних варіантів використання об’єкту. У ком’ютерних науках так позначають колекцію елементів, яка підтримує дві операції:
+[Черга](https://uk.wikipedia.org/wiki/Черга_(структура_даних)) — один з найбільш популярних варіантів використання об'єкту. У ком'ютерних науках так позначають колекцію елементів, яка підтримує дві операції:
 
 - `push` додає елемент у кінець списку.
 - `shift` видаляє елемент на початку, зміщчуючи чергу, таким чином, що 2-й елемент стає 1-м.
@@ -155,7 +155,7 @@ alert( fruits.at(-1) ); // Plum
 
 Масиви в JavaScript можуть працювати як стеки і як черги. Ми можемо додавати/видаляти елементи як на початку так і у кінці масиву.
 
-В комп’ютерних науках структури даних, які дозволяють це робити, мають назву [двобічна черга](https://uk.wikipedia.org/wiki/Двобічна_черга).
+В комп'ютерних науках структури даних, які дозволяють це робити, мають назву [двобічна черга](https://uk.wikipedia.org/wiki/Двобічна_черга).
 
 **Методи, які працюють з кінцем масиву:**
 
@@ -223,11 +223,11 @@ alert( fruits );
 
 ## Внутрішня структура масивів
 
-Масив -- це спеціальний вид об’єктів. Квадратні дужки використовують для доступу до властивості `arr[0]`, що в свою чергу прийшло з синтаксису об’єктів. Це теж саме, що доступ до властивості об’єкта `obj[key]`, де `arr` це об’єкт в якому числа використовуються як ключі.
+Масив -- це спеціальний вид об'єктів. Квадратні дужки використовують для доступу до властивості `arr[0]`, що в свою чергу прийшло з синтаксису об'єктів. Це теж саме, що доступ до властивості об'єкта `obj[key]`, де `arr` це об'єкт в якому числа використовуються як ключі.
 
-Масиви розширюють функціональність об’єкта тим, що надають можливість працювати з упорядкованими колекціями даних, а також надають доступ до властивості `length`. Але в основі це досі об’єкт.
+Масиви розширюють функціональність об'єкта тим, що надають можливість працювати з упорядкованими колекціями даних, а також надають доступ до властивості `length`. Але в основі це досі об'єкт.
 
-Запам’ятайте, JavaScript містить лише 8 базових типів даних (більше інформації у розділі [Типи даних](info:types)). Масив -- це об’єкт, який поводить себе як об’єкт.
+Запам'ятайте, JavaScript містить лише 8 базових типів даних (більше інформації у розділі [Типи даних](info:types)). Масив -- це об'єкт, який поводить себе як об'єкт.
 
 Наприклад, копіюється за посиланням:
 
@@ -243,9 +243,9 @@ arr.push("Pear"); // зміна масиву за посиланням
 alert( fruits ); // Banana, Pear - наразі два елемента
 ```
 
-...Але те, що робить масиви дійсно особливими – це їх внутрішнє представлення. Рушій JavaScript намагається зберігати елементи масиву у неперервній області пам’яті, один за одним, як це представлено на ілюстраціях в цьому розділі, а також застосовує інші способи оптимізації, що дозволяють масивам працювати дуже швидко.
+...Але те, що робить масиви дійсно особливими – це їх внутрішнє представлення. Рушій JavaScript намагається зберігати елементи масиву у неперервній області пам'яті, один за одним, як це представлено на ілюстраціях в цьому розділі, а також застосовує інші способи оптимізації, що дозволяють масивам працювати дуже швидко.
 
-Проте масиви втратять всю свою ефективність, якщо ми перестанемо працювати з ними як з "упорядкованою колекцією даних" і почнемо використовувати як звичайний об’єкт.
+Проте масиви втратять всю свою ефективність, якщо ми перестанемо працювати з ними як з "упорядкованою колекцією даних" і почнемо використовувати як звичайний об'єкт.
 
 Наприклад, технічно ми можемо виконати наступне:
 
@@ -254,12 +254,12 @@ let fruits = []; // створюємо масив
 
 fruits[99999] = 5; // створюємо властивість, індекс якої набагато перевищує довжину масиву
 
-fruits.age = 25; // створюємо властивість з довільним ім’ям
+fruits.age = 25; // створюємо властивість з довільним ім'ям
 ```
 
-Це можливо тому, що в основі масивів — об’єкти. Ми можемо додати будь-які властивості до них.
+Це можливо тому, що в основі масивів — об'єкти. Ми можемо додати будь-які властивості до них.
 
-Але рушій зрозуміє, що ми використувуємо масиви, як звичайні об’єкти. Методи оптимізації, які використовуються для масивів в цьому випадку не підходять, тому будуть відключені і не принесуть ніякої користі.
+Але рушій зрозуміє, що ми використувуємо масиви, як звичайні об'єкти. Методи оптимізації, які використовуються для масивів в цьому випадку не підходять, тому будуть відключені і не принесуть ніякої користі.
 
 Варіанти неправильного використання масивів:
 
@@ -267,7 +267,7 @@ fruits.age = 25; // створюємо властивість з довільн
 - Створення "дірок", наприклад: `arr[0]` а за ним `arr[1000]` (та нічого між цими елементами).
 - Заповнення масиву в зворотньому порядку, наприклад: `arr[1000]`, `arr[999]` і т. д.
 
-Будь ласка, думайте про масиви як про особливі структури для роботи з _впорядкованими даними_. Вони надають спеціальні методи для цього. Масиви дуже ретельно налаштовані на роботу з неперервними впорядкованими даними, тому використовуйте їх саме таким чином. Тому, якщо вам необхідні довільні ключі, дуже ймовірно, що вам більше підійдуть звичайні об’єкти `{}`.
+Будь ласка, думайте про масиви як про особливі структури для роботи з _впорядкованими даними_. Вони надають спеціальні методи для цього. Масиви дуже ретельно налаштовані на роботу з неперервними впорядкованими даними, тому використовуйте їх саме таким чином. Тому, якщо вам необхідні довільні ключі, дуже ймовірно, що вам більше підійдуть звичайні об'єкти `{}`.
 
 ## Продуктивність
 
@@ -291,7 +291,7 @@ fruits.shift(); // видалити один елемент з початку
 
 ![](array-shift.svg)
 
-**Чим більше елементів у масиві, тим більше часу необхідно для того, щоб пересунути їх, більше операцій з пам’яттю.**
+**Чим більше елементів у масиві, тим більше часу необхідно для того, щоб пересунути їх, більше операцій з пам'яттю.**
 
 Теж саме відбувається з методом `unshift`: для того, щоб додати елемент в початок масиву, необхідно спочатку перемістити всі елементи масиву вправо збільшуючи їх індекси.
 
@@ -336,7 +336,7 @@ for (let fruit of fruits) {
 
 Цикл `for..of` не надає доступу до індексу поточного елементу, тільки до його значення, але у більшості випадків цього достатньо. До того ж, це коротше.
 
-Технічно, так як масив це об’єкт, ми можемо використовувати цикл `for..in`:
+Технічно, так як масив це об'єкт, ми можемо використовувати цикл `for..in`:
 
 ```js run
 let arr = ["Apple", "Orange", "Pear"];
@@ -352,9 +352,9 @@ for (let key in arr) {
 
 1. Цикл `for..in` ітерується по *всіх властивостях*, не тільки по числових.
 
-    У браузерах та різних програмних середовищах існують масивоподібні об’єкти, *які виглядають як масив*. Тобто вони мають властивість `length` та індекси, проте вони також містять інші нечислові властивості і методи, які нам часто не потрібні. Цикл `for..in` відобразить і їх. Тому, коли нам необхідно працювати з масивами, ці "екстра" властивості можуть стати проблемою.
+    У браузерах та різних програмних середовищах існують масивоподібні об'єкти, *які виглядають як масив*. Тобто вони мають властивість `length` та індекси, проте вони також містять інші нечислові властивості і методи, які нам часто не потрібні. Цикл `for..in` відобразить і їх. Тому, коли нам необхідно працювати з масивами, ці "екстра" властивості можуть стати проблемою.
 
-2. Цикл `for..in` оптимізований для довільних об’єктів, не для масивів, і тому в 10-100 разів повільніше. Звісно, це все одно дуже швидко. Збільшення швидкості виконання має значення лише у *вузьких місцях*. Але ми все одно повинні бути обережні з відмінностями.
+2. Цикл `for..in` оптимізований для довільних об'єктів, не для масивів, і тому в 10-100 разів повільніше. Звісно, це все одно дуже швидко. Збільшення швидкості виконання має значення лише у *вузьких місцях*. Але ми все одно повинні бути обережні з відмінностями.
 
 Словом, не варто використовувати цикл `for..in` для масивів.
 
@@ -465,12 +465,12 @@ alert( "1,2" + 1 ); // "1,21"
 
 На відміну від інших мов програмування, масиви в JavaScript не варто порівнювати за допомогою оператора `==`.
 
-Цей оператор не має спеціальних методів для опрацювання масивів, тому він працює з ними, як з об’єктами.
+Цей оператор не має спеціальних методів для опрацювання масивів, тому він працює з ними, як з об'єктами.
 
 Давайте згадаємо правила:
 
-- Два об’єкти рівні `==` лише коли вони посилаються на один об’єкт.
-- Якщо один з аргументів оператора `==` об’єкт, а інший — примітив, тоді об’єкт конвертується в примітив. Це пояснюється в розділі <info:object-toprimitive>.
+- Два об'єкти рівні `==` лише коли вони посилаються на один об'єкт.
+- Якщо один з аргументів оператора `==` об'єкт, а інший — примітив, тоді об'єкт конвертується в примітив. Це пояснюється в розділі <info:object-toprimitive>.
 - ...Лише два виключення — це `null` та `undefined`, які рівні `==` один одному та нічому більше.
 
 Строге порівняння `===` ще простіше, тому що не конвертує типи. 
@@ -483,7 +483,7 @@ alert( [] == [] ); // false
 alert( [0] == [0] ); // false
 ```
 
-Технічно ці масиви, це різні об’єкти. Тому вони не рівні. Оператор `==` не порівнює елемент за елементом.
+Технічно ці масиви, це різні об'єкти. Тому вони не рівні. Оператор `==` не порівнює елемент за елементом.
 
 Порівняння масиву з примітивами теж може дати досить цікаві результати:
 
@@ -510,7 +510,7 @@ alert('0' == '' ); // false, тут немає конвертації типів
 
 ## Підсумки
 
-Масив -- це особливий вид об’єкту, створений для зберігання та обробки _впорядкованих елементів_.
+Масив -- це особливий вид об'єкту, створений для зберігання та обробки _впорядкованих елементів_.
 
 Оголошення массиву:
 
@@ -544,7 +544,7 @@ let arr = new Array(item1, item2...);
   - `for (let item of arr)` — новий синтаксис, лише для значень елементів (відсутній доступ до індексів масиву).
   - `for (let i in arr)` — ніколи не використовуйте!
 
-Для порівняння масивів, не використовуйте оператор `==` (так само, як `>`, `<` та інші), тому що в них немає спеціальних методів для порівнювання масивів. Ці оператори працюють з масивами як з об’єктами, а це не те, що нам потрібно.
+Для порівняння масивів, не використовуйте оператор `==` (так само, як `>`, `<` та інші), тому що в них немає спеціальних методів для порівнювання масивів. Ці оператори працюють з масивами як з об'єктами, а це не те, що нам потрібно.
 
 Натомість, для порівняння масивів використовуйте цикл `for..of`, щоб порівнювати елемент за елементом.
 
diff --git a/1-js/05-data-types/05-array-methods/10-average-age/task.md b/1-js/05-data-types/05-array-methods/10-average-age/task.md
index 685c4e5f2..263984c72 100644
--- a/1-js/05-data-types/05-array-methods/10-average-age/task.md
+++ b/1-js/05-data-types/05-array-methods/10-average-age/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Вирахувати середній вік
 
-Напишіть функцію `getAverageAge(users)`, яка приймає масив об’єктів з властивістю `age` та повертає середній вік.
+Напишіть функцію `getAverageAge(users)`, яка приймає масив об'єктів з властивістю `age` та повертає середній вік.
 
 Формула обчислення середнього арифметичного значення: `(age1 + age2 + ... + ageN) / N`.
 
diff --git a/1-js/05-data-types/05-array-methods/12-reduce-object/task.md b/1-js/05-data-types/05-array-methods/12-reduce-object/task.md
index ecc0436a7..d0f526fbe 100644
--- a/1-js/05-data-types/05-array-methods/12-reduce-object/task.md
+++ b/1-js/05-data-types/05-array-methods/12-reduce-object/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Створення об’єкта з ключем з масиву
+# Створення об'єкта з ключем з масиву
 
 Припустимо, ми отримали масив користувачів у вигляді `{id:..., name:..., age:...}`.
 
-Створіть функцію `groupById(arr)`, яка створює з масиву об’єкт із ключом `id` та елементами масиву як значеннями.
+Створіть функцію `groupById(arr)`, яка створює з масиву об'єкт із ключом `id` та елементами масиву як значеннями.
 
 Наприклад:
 
diff --git a/1-js/05-data-types/05-array-methods/6-array-get-names/task.md b/1-js/05-data-types/05-array-methods/6-array-get-names/task.md
index 3b4130f86..48f77895d 100644
--- a/1-js/05-data-types/05-array-methods/6-array-get-names/task.md
+++ b/1-js/05-data-types/05-array-methods/6-array-get-names/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Трансформувати в масив імен
 
-У вас є масив об’єктів user, і в кожному з них є `user.name`. Напишіть код, який перетворює їх в масив імен.
+У вас є масив об'єктів user, і в кожному з них є `user.name`. Напишіть код, який перетворює їх в масив імен.
 
 Наприклад:
 
diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md
index c4d9698f4..de8bbd8de 100644
--- a/1-js/05-data-types/05-array-methods/article.md
+++ b/1-js/05-data-types/05-array-methods/article.md
@@ -17,7 +17,7 @@
 
 Як видалити елемент з масиву?
 
-Масиви є об’єктами, тому ми можемо спробувати використати `delete`:
+Масиви є об'єктами, тому ми можемо спробувати використати `delete`:
 
 ```js run
 let arr = ["I", "go", "home"];
diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index fb0f4ae2f..8dcc0731d 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -1,20 +1,20 @@
 
-# Ітеративні об’єкти
+# Ітеративні об'єкти
 
-*Ітеративні* об’єкти є узагальненням масивів. Це концепція, яка дозволяє нам зробити будь-який об’єкт придатним для використання в циклі `for..of`.
+*Ітеративні* об'єкти є узагальненням масивів. Це концепція, яка дозволяє нам зробити будь-який об'єкт придатним для використання в циклі `for..of`.
 
-Звичайно, по масивах можна ітеруватися. Але є багато інших вбудованих об’єктів, які також можна ітерувати. Наприклад, рядки також можна ітерувати.
+Звичайно, по масивах можна ітеруватися. Але є багато інших вбудованих об'єктів, які також можна ітерувати. Наприклад, рядки також можна ітерувати.
 
-Якщо об’єкт технічно не є масивом, а представляє колекцію (list, set) чогось, то `for..of` -- чудовий синтаксис для його обходу, тому подивімось, як змусити його працювати.
+Якщо об'єкт технічно не є масивом, а представляє колекцію (list, set) чогось, то `for..of` -- чудовий синтаксис для його обходу, тому подивімось, як змусити його працювати.
 
 
 ## Symbol.iterator
 
-Ми можемо легко зрозуміти концепцію ітеративних об’єктів, зробивши її власноруч.
+Ми можемо легко зрозуміти концепцію ітеративних об'єктів, зробивши її власноруч.
 
-Наприклад, у нас є об’єкт, який не є масивом, але виглядає придатним для `for..of`.
+Наприклад, у нас є об'єкт, який не є масивом, але виглядає придатним для `for..of`.
 
-Як, наприклад, об’єкт `range`, який представляє інтервал чисел:
+Як, наприклад, об'єкт `range`, який представляє інтервал чисел:
 
 ```js
 let range = {
@@ -26,14 +26,14 @@ let range = {
 // for(let num of range) ... num=1,2,3,4,5
 ```
 
-Щоб зробити об’єкт `range` ітерабельним (і таким чином дозволити `for..of` працювати), нам потрібно додати метод до об’єкта з назвою `Symbol.iterator` (спеціальний вбудований символ саме для цього).
+Щоб зробити об'єкт `range` ітерабельним (і таким чином дозволити `for..of` працювати), нам потрібно додати метод до об'єкта з назвою `Symbol.iterator` (спеціальний вбудований символ саме для цього).
 
-1. Коли `for..of` запускається, він викликає цей метод один раз (або викидає помилку, якщо цей метод не знайдено). Метод повинен повернути *iterator* -- об’єкт з методом `next`.
-2. Далі `for..of` працює *лише з поверненим об’єктом*.
-3. Коли `for..of` хоче отримати наступне значення, він викликає `next()` на цьому об’єкті.
+1. Коли `for..of` запускається, він викликає цей метод один раз (або викидає помилку, якщо цей метод не знайдено). Метод повинен повернути *iterator* -- об'єкт з методом `next`.
+2. Далі `for..of` працює *лише з поверненим об'єктом*.
+3. Коли `for..of` хоче отримати наступне значення, він викликає `next()` на цьому об'єкті.
 4. Результат `next()` повинен мати вигляд `{done: Boolean, value: any}`, де `done=true` означає, що ітерація завершена, інакше `value` -- це наступне значення.
 
-Ось повна реалізація об’єкту `range` із зауваженнями:
+Ось повна реалізація об'єкту `range` із зауваженнями:
 
 ```js run
 let range = {
@@ -50,7 +50,7 @@ range[Symbol.iterator] = function() {
    last: this.to,
       
     next() {
-      // 4. він повинен повертати значення як об’єкт {done:.., value :...}
+      // 4. він повинен повертати значення як об'єкт {done:.., value :...}
       if (this.current <= this.last) {
         return { done: false, value: this.current++ };
       } else {
@@ -66,14 +66,14 @@ for (let num of range) {
 }
 ```
 
-Будь ласка, зверніть увагу на основну особливість ітеративних об’єктів: розділення проблем.
+Будь ласка, зверніть увагу на основну особливість ітеративних об'єктів: розділення проблем.
 
 - Сам `range` не має методу `next()`.
-- Натомість інший об’єкт, так званий "ітератор", створюється за допомогою виклику `range[Symbol.iterator]()`, а його `next()` генерує значення для ітерації.
+- Натомість інший об'єкт, так званий "ітератор", створюється за допомогою виклику `range[Symbol.iterator]()`, а його `next()` генерує значення для ітерації.
 
-Отже, об’єкт, що ітерує відокремлений від об’єкта, який він ітерує.
+Отже, об'єкт, що ітерує відокремлений від об'єкта, який він ітерує.
 
-Технічно, ми можемо об’єднати їх і використовувати `range` в якості ітератора, щоб зробити код простішим.
+Технічно, ми можемо об'єднати їх і використовувати `range` в якості ітератора, щоб зробити код простішим.
 
 Подібно до цього:
 
@@ -101,16 +101,16 @@ for (let num of range) {
 }
 ```
 
-Тепер `range[Symbol.iterator]()` повертає сам об’єкт `range`: він має необхідний `next()` метод і пам’ятає поточну ітерацію прогресу в `this.current`. Коротше? Так. А іноді це також добре.
+Тепер `range[Symbol.iterator]()` повертає сам об'єкт `range`: він має необхідний `next()` метод і пам'ятає поточну ітерацію прогресу в `this.current`. Коротше? Так. А іноді це також добре.
 
-Недоліком є те, що тепер неможливо мати два `for..of` цикли паралельно для проходження через об’єкт: вони будуть ділити ітераційний стан, тому що є тільки один ітератор -- сам об’єкт. Але два паралельних for-of це рідкісний випадок, навіть у асинхронізованих сценаріях.
+Недоліком є те, що тепер неможливо мати два `for..of` цикли паралельно для проходження через об'єкт: вони будуть ділити ітераційний стан, тому що є тільки один ітератор -- сам об'єкт. Але два паралельних for-of це рідкісний випадок, навіть у асинхронізованих сценаріях.
 
 ```smart header="Infinite iterators"
-Також можливі нескінченні ітератори. Наприклад, `range` стає нескінченним для `range.to = Infinity`. Або ми можемо зробити ітерований об’єкт, який генерує нескінченну послідовність псевдорандомних чисел. Це також може бути корисним.
+Також можливі нескінченні ітератори. Наприклад, `range` стає нескінченним для `range.to = Infinity`. Або ми можемо зробити ітерований об'єкт, який генерує нескінченну послідовність псевдорандомних чисел. Це також може бути корисним.
 
 Немає обмежень на `next`, він може повертати все більше і більше значень, це нормально.
 
-Звичайно, `for..of` цикли через такий об’єкт буде нескінченним. Але ми завжди можемо зупинити його за допомогою `break`.
+Звичайно, `for..of` цикли через такий об'єкт буде нескінченним. Але ми завжди можемо зупинити його за допомогою `break`.
 ```
 
 
@@ -161,21 +161,21 @@ while (true) {
 
 Це рідко потрібно, але дає нам більше контролю над процесом, ніж `for ..of`. Наприклад, ми можемо розділити процес ітерації: трохи ітерувати, а потім зупинитися, зробити щось інше, а потім відновити пізніше.
 
-## Ітеровані об’єкти та псевдомасиви [#array-like]
+## Ітеровані об'єкти та псевдомасиви [#array-like]
 
 Ці два офіційних терміни виглядають подібними, але дуже різні. Будь ласка, переконайтеся, що ви добре розумієте їх, щоб уникнути плутанини.
 
-- *Ітеровані* -- це об’єкти, які реалізують метод `Symbol.iterator`, як описано вище.
-- *Псевдомасиви* -- це об’єкти, які мають індекси та `length`, тому вони виглядають як масиви.
+- *Ітеровані* -- це об'єкти, які реалізують метод `Symbol.iterator`, як описано вище.
+- *Псевдомасиви* -- це об'єкти, які мають індекси та `length`, тому вони виглядають як масиви.
 
-Коли ми використовуємо JavaScript для практичних завдань у браузері або будь-якому іншому середовищі, ми можемо зустріти об’єкти, які є ітерованими або масивами, або обома.
-Наприклад, рядки є ітерованими об’єктами (`for..of` працює на них) та псевдомасивами (у них є числові індекси та `length`).
+Коли ми використовуємо JavaScript для практичних завдань у браузері або будь-якому іншому середовищі, ми можемо зустріти об'єкти, які є ітерованими або масивами, або обома.
+Наприклад, рядки є ітерованими об'єктами (`for..of` працює на них) та псевдомасивами (у них є числові індекси та `length`).
 
-Але ітерований об’єкт може не бути масивом. І навпаки, псевдомасив може бути не ітерованим об’єктом.
+Але ітерований об'єкт може не бути масивом. І навпаки, псевдомасив може бути не ітерованим об'єктом.
 
-Наприклад, `range` у прикладі вище є ітерованим об’єктом, але не масивом, тому що він не має індексованих властивостей та `length`.
+Наприклад, `range` у прикладі вище є ітерованим об'єктом, але не масивом, тому що він не має індексованих властивостей та `length`.
 
-І ось об’єкт, який є псевдомасивом, але не ітерованим об’єктом:
+І ось об'єкт, який є псевдомасивом, але не ітерованим об'єктом:
 
 ```js run
 let arrayLike = { // має індекси та length => псевдомасив
@@ -190,11 +190,11 @@ for (let item of arrayLike) {}
 */!*
 ```
 
-Обидва, ітерований об’єкт та псевдомасив, як правило є *не масивами*, вони не мають `push`,` pop` та ін. Це досить незручно, якщо у нас є такий об’єкт і ми хочемо працювати з ним як з масивом. Наприклад, ми хотіли б працювати з `angy` за допомогою методів масиву. Як цього досягти?
+Обидва, ітерований об'єкт та псевдомасив, як правило є *не масивами*, вони не мають `push`,` pop` та ін. Це досить незручно, якщо у нас є такий об'єкт і ми хочемо працювати з ним як з масивом. Наприклад, ми хотіли б працювати з `angy` за допомогою методів масиву. Як цього досягти?
 
 ## Array.from
 
-Існує універсальний метод [Array.from](mdn:js/Array/from), який приймає ітерований об’єкт або псевдомасив і робить з нього "справжній" масив. Тоді ми можемо викликати на ньому методи масиву.
+Існує універсальний метод [Array.from](mdn:js/Array/from), який приймає ітерований об'єкт або псевдомасив і робить з нього "справжній" масив. Тоді ми можемо викликати на ньому методи масиву.
 
 Наприклад:
 
@@ -211,9 +211,9 @@ let arr = Array.from(arrayLike); // (*)
 alert(arr.pop()); // Світ (метод працює)
 ```
 
-`Array.from` у рядку `(*)` бере об’єкт, перевіряє його на ітерабельність або те, що це псевдомасив, потім створює новий масив і копіює до нього всі елементи.
+`Array.from` у рядку `(*)` бере об'єкт, перевіряє його на ітерабельність або те, що це псевдомасив, потім створює новий масив і копіює до нього всі елементи.
 
-Те ж саме відбувається і з ітерованим об’єктом:
+Те ж саме відбувається і з ітерованим об'єктом:
 
 ```js run
 // припустимо, що діапазон взятий з наведеного вище прикладу
@@ -244,7 +244,7 @@ alert(arr); // 1,4,9,16,25
 ```js run
 let str = '𝒳😂';
 
-// розіб’ємо рядок на масив символів
+// розіб'ємо рядок на масив символів
 let chars = Array.from(str);
 
 alert(chars[0]); // 𝒳
@@ -285,18 +285,18 @@ alert( str.slice(1, 3) ); // сміття (дві частини різних с
 
 ## Підсумки
 
-Об’єкти, які можна використовуватися у `for..of`, називаються *ітерованими*.
+Об'єкти, які можна використовуватися у `for..of`, називаються *ітерованими*.
 
-- Технічно ітеровані об’єкти повинні реалізовувати метод з назвою `Symbol.iterator`.
+- Технічно ітеровані об'єкти повинні реалізовувати метод з назвою `Symbol.iterator`.
     - Результат `obj[Symbol.iterator]()` називається *ітератором*. Він забезпечує подальший процес ітерації.
-    - Ітератор повинен мати метод з назвою `next()`, який повертає об’єкт `{done: Boolean, value: any}`, де `done: true` означає кінець процесу ітерації, інакше `value` є наступним значенням.
+    - Ітератор повинен мати метод з назвою `next()`, який повертає об'єкт `{done: Boolean, value: any}`, де `done: true` означає кінець процесу ітерації, інакше `value` є наступним значенням.
 - Метод `Symbol.iterator` автоматично викликається `for..of`, але ми також можемо це зробити безпосередньо.
-- Вбудовані ітеровані об’єкти, такі як рядки або масиви, також реалізують `Symbol.iterator`.
+- Вбудовані ітеровані об'єкти, такі як рядки або масиви, також реалізують `Symbol.iterator`.
 - Рядковий ітератор знає про сурогатні пари.
 
 
-Об’єкти, які мають індексовані властивості та `length`, називаються *псевдомасивами*. Такі об’єкти також можуть мати інші властивості та методи, але не мають вбудованих методів масивів.
+Об'єкти, які мають індексовані властивості та `length`, називаються *псевдомасивами*. Такі об'єкти також можуть мати інші властивості та методи, але не мають вбудованих методів масивів.
 
-Якщо ми заглянемо в специфікацію -- ми побачимо, що більшість вбудованих методів припускають, що вони працюють з ітерованими об’єктами або псевдомасивами замість "реальних" масивів, тому що це більш абстрактно.
+Якщо ми заглянемо в специфікацію -- ми побачимо, що більшість вбудованих методів припускають, що вони працюють з ітерованими об'єктами або псевдомасивами замість "реальних" масивів, тому що це більш абстрактно.
 
-`Array.from(obj[, mapFn, thisArg])` створює справжній `Array` з ітерованого об’єкту або псевдомасиву `obj`, і тоді ми можемо використовувати на ньому методи масиву. Необов’язкові аргументи `mapFn` та` thisArg` дозволяють нам застосовувати функції до кожного елемента.
+`Array.from(obj[, mapFn, thisArg])` створює справжній `Array` з ітерованого об'єкту або псевдомасиву `obj`, і тоді ми можемо використовувати на ньому методи масиву. Необов'язкові аргументи `mapFn` та` thisArg` дозволяють нам застосовувати функції до кожного елемента.
diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 0bd23a5a8..04ae5326c 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -3,7 +3,7 @@
 
 Зараз ми знаємо про наступні складні структури даних:
 
-- Об’єкти для зберігання іменованих колекцій.
+- Об'єкти для зберігання іменованих колекцій.
 - Масиви для зберігання впорядкованих колекцій.
 
 Але цього не завжди достатньо в реальному житті. Ось чому існують `Map` та `Set`.
@@ -31,7 +31,7 @@ map.set('1', 'str1');   // рядок як ключ
 map.set(1, 'num1');     // цифра як ключ
 map.set(true, 'bool1'); // булеве значення як ключ
 
-// пам’ятаєте звичайний об’єкт `Object`? Він перетворює всі ключі в рядок
+// пам'ятаєте звичайний об'єкт `Object`? Він перетворює всі ключі в рядок
 // Map зберігає тип ключів, так що в цьому випадку ми отримаємо 2 різних значення:
 alert( map.get(1) );   // 'num1'
 alert( map.get('1') ); // 'str1'
@@ -39,15 +39,15 @@ alert( map.get('1') ); // 'str1'
 alert( map.size ); // 3
 ```
 
-Як ми бачимо, на відміну від об’єктів, ключі не були приведені до рядків. Можна використовувати будь-які типи даних для ключів.
+Як ми бачимо, на відміну від об'єктів, ключі не були приведені до рядків. Можна використовувати будь-які типи даних для ключів.
 
 ```smart header="`map[key]` не є правильним методом використання `Map`"
-Хоча `map[key]` також працює, але такий спосіб присвоєння `map[key] = 2` використовує колекцію як звичайний JavaScript об’єкт, тобто накладає відповідні обмеження (тільки типи рядки/символи як ключі та інше).
+Хоча `map[key]` також працює, але такий спосіб присвоєння `map[key] = 2` використовує колекцію як звичайний JavaScript об'єкт, тобто накладає відповідні обмеження (тільки типи рядки/символи як ключі та інше).
 
 Таким чином ми повинні користуватись `map` методами: `set`, `get` і так далі.
 ```
 
-**Map також може використовувати об’єкти як ключі.**
+**Map також може використовувати об'єкти як ключі.**
 
 Наприклад:
 
@@ -57,13 +57,13 @@ let ivan = { name: "Іван" };
 // збережімо кількість відвідувань для кожного користувача
 let visitsCountMap = new Map();
 
-// об’єкт ivan -- це ключ для значення в колекції Map
+// об'єкт ivan -- це ключ для значення в колекції Map
 visitsCountMap.set(ivan, 123);
 
 alert( visitsCountMap.get(ivan) ); // 123
 ```
 
-Об’єкти в якості ключів -- це одна з відомих можливостей колекції `Map`, яку часто використовують. У звичайному об’єкті `Object`, ми можемо використати ключі-рядки, проте ключі-об’єкти -- вже ні.
+Об'єкти в якості ключів -- це одна з відомих можливостей колекції `Map`, яку часто використовують. У звичайному об'єкті `Object`, ми можемо використати ключі-рядки, проте ключі-об'єкти -- вже ні.
 
 Розгляньмо такий приклад:
 
@@ -71,10 +71,10 @@ alert( visitsCountMap.get(ivan) ); // 123
 let ivan = { name: "Іван" };
 let bohdan = { name: "Богдан" };
 
-let visitsCountObj = {}; // оголосимо звичайний об’єкт
+let visitsCountObj = {}; // оголосимо звичайний об'єкт
 
-visitsCountObj[bohdan] = 234; // використаємо об’єкт `bohdan` як ключ
-visitsCountObj[ivan] = 123; // використаємо `ivan` об’єкт як ключ, `bohdan` об’єкт буде перезаписаний
+visitsCountObj[bohdan] = 234; // використаємо об'єкт `bohdan` як ключ
+visitsCountObj[ivan] = 123; // використаємо `ivan` об'єкт як ключ, `bohdan` об'єкт буде перезаписаний
 
 *!*
 // Ось як це було записано!
@@ -82,16 +82,16 @@ alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 
-Оскільки `visitsCountObj` -- це об’єкт, він конвертує всі ключі типу `Object` (такі як `ivan` і `bohdan`) до рядка `"[object Object]"`. Це однозначно не той результат, який ми очікуємо.
+Оскільки `visitsCountObj` -- це об'єкт, він конвертує всі ключі типу `Object` (такі як `ivan` і `bohdan`) до рядка `"[object Object]"`. Це однозначно не той результат, який ми очікуємо.
 
 ```smart header="Як `Map` порівнює ключі"
-Порівнюючи ключі, об’єкт `Map` використовує алгоритм [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). Це майже таке ж порівняння, що і `===`, з тією лише різницею, що `NaN` вважається рівним `NaN`. Таким чином `NaN` може також бути використаний як ключ.
+Порівнюючи ключі, об'єкт `Map` використовує алгоритм [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). Це майже таке ж порівняння, що і `===`, з тією лише різницею, що `NaN` вважається рівним `NaN`. Таким чином `NaN` може також бути використаний як ключ.
 
 Цей алгоритм не може бути замінений або модифікований.
 ```
 
 ````smart header="Послідовні виклики"
-Кожен виклик `map.set` повертає об’єкт map, таким чином ми можемо об’єднати виклики в ланцюжок:
+Кожен виклик `map.set` повертає об'єкт map, таким чином ми можемо об'єднати виклики в ланцюжок:
 
 ```js
 map.set('1', 'str1')
@@ -134,7 +134,7 @@ for (let entry of recipeMap) { // те ж саме, що recipeMap.entries()
 ```
 
 ```smart header="Використовується порядок вставки"
-На відміну від звичайних об’єктів `Object`, в `Map` перебір відбувається в тому ж порядку, в якому відбувалося додавання елементів.
+На відміну від звичайних об'єктів `Object`, в `Map` перебір відбувається в тому ж порядку, в якому відбувалося додавання елементів.
 ```
 
 Крім цього, `Map` має вбудований метод `forEach`, схожий з вбудованим методом масивів `Array`:
@@ -148,7 +148,7 @@ recipeMap.forEach( (value, key, map) => {
 
 ## Object.entries: Map з Object
 
-При створенні `Map` ми можемо вказати масив (або інший об’єкт-ітератор) з парами ключ-значення для ініціалізації, як тут:
+При створенні `Map` ми можемо вказати масив (або інший об'єкт-ітератор) з парами ключ-значення для ініціалізації, як тут:
 
 ```js run
 // масив пар [ключ, значення]
@@ -161,9 +161,9 @@ let map = new Map([
 alert( map.get('1') ); // str1
 ```
 
-Якщо у нас вже є звичайний об’єкт, і ми б хотіли створити з нього `Map`, то допоможе вбудований метод [Object.entries(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries), котрий отримує об’єкт і повертає масив пар ключ-значення для нього, як раз в цьому форматі.
+Якщо у нас вже є звичайний об'єкт, і ми б хотіли створити з нього `Map`, то допоможе вбудований метод [Object.entries(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries), котрий отримує об'єкт і повертає масив пар ключ-значення для нього, як раз в цьому форматі.
 
-Таким чином ми можемо створити `Map` з об’єкта наступним чином:
+Таким чином ми можемо створити `Map` з об'єкта наступним чином:
 
 ```js run
 let obj = {
@@ -183,9 +183,9 @@ alert( map.get('name') ); // Іван
 
 ## Object.fromEntries: Object з Map
 
-Ми щойно створювали `Map` з простого об’єкта за допомогою `Object.entries(obj)`.
+Ми щойно створювали `Map` з простого об'єкта за допомогою `Object.entries(obj)`.
 
-Ми можемо використати `Object.fromEntries` метод, який виконає зворотну дію: трансформує отриманий масив пар `[ключ, значення]` в об’єкт. Наприклад:
+Ми можемо використати `Object.fromEntries` метод, який виконає зворотну дію: трансформує отриманий масив пар `[ключ, значення]` в об'єкт. Наприклад:
 
 ```js run
 let prices = Object.fromEntries([
@@ -199,9 +199,9 @@ let prices = Object.fromEntries([
 alert(prices.апельсин); // 2
 ```
 
-Ми можемо використати `Object.fromEntries`, щоб отримати звичайний об’єкт з `Map`.
+Ми можемо використати `Object.fromEntries`, щоб отримати звичайний об'єкт з `Map`.
 
-Наприклад, ми маємо дані в `Map`, але потрібно їх передати в сторонній код, який чекає простий об’єкт.
+Наприклад, ми маємо дані в `Map`, але потрібно їх передати в сторонній код, який чекає простий об'єкт.
 
 Ось як це зробити:
 
@@ -212,7 +212,7 @@ map.set('апельсин', 2);
 map.set('яблуко', 4);
 
 *!*
-let obj = Object.fromEntries(map.entries()); // робимо простий об’єкт (*)
+let obj = Object.fromEntries(map.entries()); // робимо простий об'єкт (*)
 */!*
 
 // Готово!
@@ -228,24 +228,24 @@ alert(obj.апельсин); // 2
 let obj = Object.fromEntries(map); // прибрати .entries()
 ```
 
-Це те ж саме, оскільки `Object.fromEntries` чекає аргументом об’єкт-ітератор, не обов’язково масив. А перебір `map` якраз повертає пари ключ/значення, як і `map.entries()`. Так що в підсумку ми матимемо звичайний об’єкт з тими ж ключами/значеннями, що і в `map`.
+Це те ж саме, оскільки `Object.fromEntries` чекає аргументом об'єкт-ітератор, не обов'язково масив. А перебір `map` якраз повертає пари ключ/значення, як і `map.entries()`. Так що в підсумку ми матимемо звичайний об'єкт з тими ж ключами/значеннями, що і в `map`.
 
 ## Set
 
-Об’єкт [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) -- це особливий тип колекції: "множина" значень (без ключів), де кожне значення може з’являтися тільки раз.
+Об'єкт [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) -- це особливий тип колекції: "множина" значень (без ключів), де кожне значення може з'являтися тільки раз.
 
 Основні методи:
 
-- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- створює `Set`, якщо аргументом виступає об’єкт-ітератор, тоді значення копіюються в `Set`.
+- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- створює `Set`, якщо аргументом виступає об'єкт-ітератор, тоді значення копіюються в `Set`.
 - [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- додає нове значення до `Set`, повертає `Set`.
 - [`set.delete(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- видаляє значення з `Set`, повертає `true`, якщо `value` наявне в множині значень на момент виклику методу, інакше `false`.
 - [`set.has(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- повертає `true`, якщо `value` присутнє в множині `Set`, інакше `false`.
 - [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- видаляє всі значення множини `Set`.
 - [`set.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size) -- повертає кількість елементів в множині.
 
-Родзинкою `Set` є виклики `set.add(value)`, що повторюються з однаковими значеннями `value`. Повторні виклики цього методу не змінюють `Set`. Це причина того, що кожне значення з’являється тільки один раз.
+Родзинкою `Set` є виклики `set.add(value)`, що повторюються з однаковими значеннями `value`. Повторні виклики цього методу не змінюють `Set`. Це причина того, що кожне значення з'являється тільки один раз.
 
-Наприклад, ми очікуємо гостей, і нам необхідно скласти їх список. Але повторні записи не повинні призводити до дублікатів. Кожен гість повинен з’явитися в списку лише один раз.
+Наприклад, ми очікуємо гостей, і нам необхідно скласти їх список. Але повторні записи не повинні призводити до дублікатів. Кожен гість повинен з'явитися в списку лише один раз.
 
 Множина `Set` -- це саме те, що потрібно для цього:
 
@@ -273,9 +273,9 @@ for (let user of set) {
 
 Альтернативою множини `Set` може виступати масив для зберігання гостей і додатковий код для перевірки вже наявного елемента за допомогою [arr.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find). Але в цьому випадку буде гірша продуктивність, тому що `arr.find` проходить весь масив для перевірки наявності елемента. Множина `Set` краще оптимізована для перевірки унікальності.
 
-## Перебір об’єкта Set
+## Перебір об'єкта Set
 
-Ми можемо перебрати вміст об’єкта `set` як за допомогою методу `for..of`, так і використовуючи `forEach`:
+Ми можемо перебрати вміст об'єкта `set` як за допомогою методу `for..of`, так і використовуючи `forEach`:
 
 ```js run
 let set = new Set(["апельсини", "яблука", "банани"]);
@@ -288,15 +288,15 @@ set.forEach((value, valueAgain, set) => {
 });
 ```
 
-Зауважимо цікаву річ. Функція в `forEach` у `Set` має 3 аргументи: значення 'value', потім знову *те саме значення* 'valueAgain', і тільки потім цільовий об’єкт. Це дійсно так, значення з’являється в списку аргументів двічі.
+Зауважимо цікаву річ. Функція в `forEach` у `Set` має 3 аргументи: значення 'value', потім знову *те саме значення* 'valueAgain', і тільки потім цільовий об'єкт. Це дійсно так, значення з'являється в списку аргументів двічі.
 
-Це зроблено для сумісності з об’єктом `Map`, в якому колбек `forEach` має 3 аргумента. Виглядає трохи дивно, але в деяких випадках може допомогти легко замінити `Map` на `Set` і навпаки.
+Це зроблено для сумісності з об'єктом `Map`, в якому колбек `forEach` має 3 аргумента. Виглядає трохи дивно, але в деяких випадках може допомогти легко замінити `Map` на `Set` і навпаки.
 
 `Set` має ті ж вбудовані методи, що і `Map`:
 
-- [`set.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/keys) -- повертає об’єкт-ітератор для значень,
+- [`set.keys()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/keys) -- повертає об'єкт-ітератор для значень,
 - [`set.values()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values) -- те ж саме, що `set.keys()`, для сумісності з `Map`,
-- [`set.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries) -- повертає об’єкт-ітератор для пар виду `[значення, значення]`, присутній для сумісності з `Map`.
+- [`set.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries) -- повертає об'єкт-ітератор для пар виду `[значення, значення]`, присутній для сумісності з `Map`.
 
 ## Підсумки
 
@@ -304,7 +304,7 @@ set.forEach((value, valueAgain, set) => {
 
 Методи та властивості:
 
-- [`new Map([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- створює колекцію, можна вказати `об’єкт-ітератор` (зазвичай масив) з пар `[ключ, значення]` для ініціалізації.
+- [`new Map([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/Map) -- створює колекцію, можна вказати `об'єкт-ітератор` (зазвичай масив) з пар `[ключ, значення]` для ініціалізації.
 - [`map.set(key, value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set) -- записує по ключу `key` значення `value`.
 - [`map.get(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) -- повертає значення по `key` або `undefined`, якщо ключ `key` відсутній.
 - [`map.has(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) -- повертає `true`, якщо ключ `key` присутній в колекції, інакше `false`.
@@ -312,17 +312,17 @@ set.forEach((value, valueAgain, set) => {
 - [`map.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear) -- очищає колекцію від всіх елементів.
 - [`map.size`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size) -- повертає поточну кількість елементів.
 
-Відмінності від звичайного об’єкта `Object`:
+Відмінності від звичайного об'єкта `Object`:
 
-- Що завгодно може бути ключем, в тому числі і об’єкти.
+- Що завгодно може бути ключем, в тому числі і об'єкти.
 - Є додаткові методи, властивість `size`.
 
 [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) -- колекція унікальних значень, так звана "множина".
 
 Методи та властивості:
 
-- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- створює `Set`, можна вказати `об’єкт-ітератор` (зазвичай масив).
-- [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- додає значення (якщо воно вже є, то нічого не робить), повертає той же об’єкт `set`.
+- [`new Set([iterable])`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set) -- створює `Set`, можна вказати `об'єкт-ітератор` (зазвичай масив).
+- [`set.add(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add) -- додає значення (якщо воно вже є, то нічого не робить), повертає той же об'єкт `set`.
 - [`set.delete(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete) -- видаляє значення, повертає `true` якщо `value` було в множині на момент виклику, інакше `false`.
 - [`set.has(value)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has) -- повертає `true`, якщо значення присутній в множині, інакше `false`.
 - [`set.clear()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear) -- видаляє всі наявні значення.
diff --git a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md
index 30586dc32..be20d3845 100644
--- a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md
+++ b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md
@@ -22,14 +22,14 @@ readMessages.add(messages[0]);
 alert("Прочитано повідомлення 0: " + readMessages.has(messages[0])); // true
 
 messages.shift();
-// зараз readMessages має 1 елемент (з технічної точки зору пам’ять може бути очищена пізніше)
+// зараз readMessages має 1 елемент (з технічної точки зору пам'ять може бути очищена пізніше)
 ```
 
 `WeakSet` дозволяє зберігати набір повідомлень і легко перевірити наявність повідомлення в наборі.
 
 Він автоматично очищає себе. Компроміс полягає в тому, що ми не можемо ітеруватися через нього, не можемо отримати "всі прочитані повідомлення" від нього безпосередньо. Але ми можемо це зробити, ітеруючись через всі повідомлення та відфільтрувавши тих, що знаходяться у наборі.
 
-Інше рішення може полягати у додаванні властивості `message.isRead=true` до повідомлення після його прочитання. Оскільки об’єкти повідомлень керуються іншим кодом, це, як правило, збентежує, але ми можемо використовувати символьну властивість, щоб уникнути конфліктів.
+Інше рішення може полягати у додаванні властивості `message.isRead=true` до повідомлення після його прочитання. Оскільки об'єкти повідомлень керуються іншим кодом, це, як правило, збентежує, але ми можемо використовувати символьну властивість, щоб уникнути конфліктів.
 
 Ось так:
 ```js
diff --git a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md
index 41ff2e2f8..7e53fe96a 100644
--- a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md
+++ b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md
@@ -16,8 +16,8 @@ let messages = [
 
 Ваш код може отримати доступ до нього, але повідомлення керуються чужим кодом. Нові повідомлення додаються, старі видаляються регулярно цим кодом, і ви не знаєте точних моментів, коли це станеться.
 
-Тепер, яку структуру даних ви могли б використати для зберігання інформації про те, чи було повідомлення прочитаним? Структура повинна добре підходити, щоб дати відповідь на питання "чи він прочитаний?" для об’єкта даного повідомлення.
+Тепер, яку структуру даних ви могли б використати для зберігання інформації про те, чи було повідомлення прочитаним? Структура повинна добре підходити, щоб дати відповідь на питання "чи він прочитаний?" для об'єкта даного повідомлення.
 
 P.S. Коли повідомлення видаляється з `messages`, воно також повинне зникнути з вашої структури.
 
-P.P.S. Ми не повинні змінювати об’єкти повідомлення, додаючи до них наші властивості. Оскільки вони керуються іншим кодом, це може призвести до поганих наслідків.
+P.P.S. Ми не повинні змінювати об'єкти повідомлення, додаючи до них наші властивості. Оскільки вони керуються іншим кодом, це може призвести до поганих наслідків.
diff --git a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md
index c40b0a9da..589f1feea 100644
--- a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md
+++ b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md
@@ -11,5 +11,5 @@ let messages = [
 let readMap = new WeakMap();
 
 readMap.set(messages[0], new Date(2017, 1, 1));
-// об’єкт Date ми розглянемо пізніше
+// об'єкт Date ми розглянемо пізніше
 ```
diff --git a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md
index 52f3d7ad4..b71f9d61e 100644
--- a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md
+++ b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md
@@ -16,6 +16,6 @@ let messages = [
 
 Зараз питання наступне: яку структуру даних ви б запропонували для того, щоб зберегти інформацію: "Коли повідомлення було прочитано?".
 
-У попередньому завданні нам потрібно лише зберігати інформацію "так/ні". Тепер нам потрібно зберігати дату, і це повинно залишитися в пам’яті лише доки повідомлення не буде видалено.
+У попередньому завданні нам потрібно лише зберігати інформацію "так/ні". Тепер нам потрібно зберігати дату, і це повинно залишитися в пам'яті лише доки повідомлення не буде видалено.
 
-P.S. Дати можуть зберігатися як об’єкти вбудованого класу `Data`, що ми розглянемо пізніше.
+P.S. Дати можуть зберігатися як об'єкти вбудованого класу `Data`, що ми розглянемо пізніше.
diff --git a/1-js/05-data-types/08-weakmap-weakset/article.md b/1-js/05-data-types/08-weakmap-weakset/article.md
index e271185e4..a2a3735d7 100644
--- a/1-js/05-data-types/08-weakmap-weakset/article.md
+++ b/1-js/05-data-types/08-weakmap-weakset/article.md
@@ -1,26 +1,26 @@
 
 # WeakMap та WeakSet
 
-Як ми знаємо з розділу <info:garbage-collection>, рушій JavaScript зберігає значення в пам’яті, поки воно є "доступним" і потенційно може бути використаним.
+Як ми знаємо з розділу <info:garbage-collection>, рушій JavaScript зберігає значення в пам'яті, поки воно є "доступним" і потенційно може бути використаним.
 
 Наприклад:
 
 ```js
 let john = { name: "Іван" };
 
-// Об’єкт можна отримати, john -- це посилання на нього
+// Об'єкт можна отримати, john -- це посилання на нього
 
 // перезапишемо посилання
 john = null;
 
 *!*
-// об’єкт буде видалено з пам’яті
+// об'єкт буде видалено з пам'яті
 */!*
 ```
 
-Зазвичай властивості об’єкта або елементів масиву або іншої структури даних вважаються доступними та зберігаються в пам’яті, поки та структура даних є в пам’яті.
+Зазвичай властивості об'єкта або елементів масиву або іншої структури даних вважаються доступними та зберігаються в пам'яті, поки та структура даних є в пам'яті.
 
-Наприклад, якщо ми покладемо об’єкт в масив, то, поки масив живий, об’єкт буде живим, навіть якщо немає інших посилань на цей об’єкт.
+Наприклад, якщо ми покладемо об'єкт в масив, то, поки масив живий, об'єкт буде живим, навіть якщо немає інших посилань на цей об'єкт.
 
 Ось так:
 
@@ -32,13 +32,13 @@ let array = [ john ];
 john = null; // перезапишемо посилання
 
 *!*
-// об’єкт, на який раніше посилалася змінна john, зберігається всередині масиву
+// об'єкт, на який раніше посилалася змінна john, зберігається всередині масиву
 // тому він не буде видалений збирачем сміття
 // ми можемо отримати його як array[0]
 */!*
 ```
 
-Подібно до цього, якщо ми використовуємо об’єкт як ключ у звичайному `Map`, то в той час, коли `Map` існує, цей об’єкт також існує. Він займає пам’ять і не може бути видалений збирачем сміття.
+Подібно до цього, якщо ми використовуємо об'єкт як ключ у звичайному `Map`, то в той час, коли `Map` існує, цей об'єкт також існує. Він займає пам'ять і не може бути видалений збирачем сміття.
 
 Наприклад:
 
@@ -56,28 +56,28 @@ john = null; // перезапишемо посилання
 */!*
 ```
 
-[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- принципово відрізняється в цьому аспекті. Він не перешкоджає збиранню сміття серед об’єктів, що є ключами.
+[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- принципово відрізняється в цьому аспекті. Він не перешкоджає збиранню сміття серед об'єктів, що є ключами.
 
 Подивимося, що це означає на прикладах.
 
 ## WeakMap
 
-Перша відмінність між [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) та [`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- це те, що ключі повинні бути об’єктами, а не примітивними значеннями:
+Перша відмінність між [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) та [`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- це те, що ключі повинні бути об'єктами, а не примітивними значеннями:
 
 ```js run
 let weakMap = new WeakMap();
 
 let obj = {};
 
-weakMap.set(obj, "ок"); // працює (об’єкт є ключем)
+weakMap.set(obj, "ок"); // працює (об'єкт є ключем)
 
 *!*
 // не можна використовувати рядок як ключ
-weakMap.set("тест", "Ой!"); // Помилка, тому що "тест" не є об’єктом
+weakMap.set("тест", "Ой!"); // Помилка, тому що "тест" не є об'єктом
 */!*
 ```
 
-Тепер, якщо ми використовуємо об’єкт як ключ, і немає інших посилань на цей об’єкт -- його буде видалено з пам’яті (і з мапи) автоматично.
+Тепер, якщо ми використовуємо об'єкт як ключ, і немає інших посилань на цей об'єкт -- його буде видалено з пам'яті (і з мапи) автоматично.
 
 ```js
 let john = { name: "Іван" };
@@ -87,10 +87,10 @@ weakMap.set(john, "...");
 
 john = null; // перезапишемо посилання
 
-// john видалено з пам’яті!
+// john видалено з пам'яті!
 ```
 
-Порівняйте його зі звичайним `Map`, що наведений вище. Тепер, якщо `john` існує лише як ключ `WeakMap` -- він буде автоматично видалений з мапи (і з пам’яті).
+Порівняйте його зі звичайним `Map`, що наведений вище. Тепер, якщо `john` існує лише як ключ `WeakMap` -- він буде автоматично видалений з мапи (і з пам'яті).
 
 `WeakMap` не підтримує ітерацію та методи `keys()`, `values()`, `entries()`, тому немає способу отримати всі ключі або значення від нього.
 
@@ -101,9 +101,9 @@ john = null; // перезапишемо посилання
 - [`weakMap.delete(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/delete)
 - [`weakMap.has(key)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/has)
 
-Чому є таке обмеження? Це з технічних причин. Якщо об’єкт втратив всі інші посилання (наприклад, `john` у коді вище), то він буде автоматично видалений збирачем сміття. Але технічно немає точних вказівок *коли відбувається видалення*.
+Чому є таке обмеження? Це з технічних причин. Якщо об'єкт втратив всі інші посилання (наприклад, `john` у коді вище), то він буде автоматично видалений збирачем сміття. Але технічно немає точних вказівок *коли відбувається видалення*.
 
-Рушій JavaScript вирішує це. Він може вибрати очищення пам’яті негайно або почекати, і зробити очищення пізніше, коли трапиться більше видалень. Отже, технічно, поточна кількість елементів `WeakMap` невідома. Рушій, можливо, очистив його чи ні, або зробив це частково. З цієї причини методи, які дають доступ до всіх ключів/значень не підтримуються.
+Рушій JavaScript вирішує це. Він може вибрати очищення пам'яті негайно або почекати, і зробити очищення пізніше, коли трапиться більше видалень. Отже, технічно, поточна кількість елементів `WeakMap` невідома. Рушій, можливо, очистив його чи ні, або зробив це частково. З цієї причини методи, які дають доступ до всіх ключів/значень не підтримуються.
 
 Отже, де нам потрібна така структура даних?
 
@@ -111,18 +111,18 @@ john = null; // перезапишемо посилання
 
 Основна область застосування для `WeakMap` -- це *зберігання додаткових даних*.
 
-Якщо ми працюємо з об’єктом, що "належить" до іншого коду, можливо навіть сторонньої бібліотеки, і хотіли б зберегти деякі дані, пов’язані з ним, що повинні існувати лише поки об’єкт живий -- тоді `WeakMap` цє саме те, що потрібно.
+Якщо ми працюємо з об'єктом, що "належить" до іншого коду, можливо навіть сторонньої бібліотеки, і хотіли б зберегти деякі дані, пов'язані з ним, що повинні існувати лише поки об'єкт живий -- тоді `WeakMap` цє саме те, що потрібно.
 
-Ми покладемо дані в `WeakMap`, використовуючи об’єкт як ключ, і коли об’єкт буде видалено збирачем сміття, то ці дані також автоматично зникнуть.
+Ми покладемо дані в `WeakMap`, використовуючи об'єкт як ключ, і коли об'єкт буде видалено збирачем сміття, то ці дані також автоматично зникнуть.
 
 ```js
 weakMap.set(john, "секретні документи");
-// якщо об’єкт john зникне, секретні документи будуть знищені автоматично
+// якщо об'єкт john зникне, секретні документи будуть знищені автоматично
 ```
 
 Подивімося на приклад.
 
-У нас є код, який зберігає кількість відвідувань користувачів. Інформація зберігається в мапі: об’єкт користувачів є ключем, а кількість відвідувань -- це значення. Коли користувач зникає (його об’єкт видаляється збирачем сміття), ми більше не хочемо зберігати його кількість відвідувань.
+У нас є код, який зберігає кількість відвідувань користувачів. Інформація зберігається в мапі: об'єкт користувачів є ключем, а кількість відвідувань -- це значення. Коли користувач зникає (його об'єкт видаляється збирачем сміття), ми більше не хочемо зберігати його кількість відвідувань.
 
 Ось приклад функції підрахунку з `Map`:
 
@@ -149,9 +149,9 @@ countUser(john); // рахує його візити
 john = null;
 ```
 
-Зараз, об’єкт `john` повинен бути видалений збирачем сміттям, але залишається в пам’яті тому, що це ключ `visitsCountMap`.
+Зараз, об'єкт `john` повинен бути видалений збирачем сміттям, але залишається в пам'яті тому, що це ключ `visitsCountMap`.
 
-Нам потрібно очищувати `visitsCountMap`, коли ми видаляємо користувачів, інакше він буде рости в пам’яті необмежено довго. Таке очищення може стати нудним завданням у складних архітектурах.
+Нам потрібно очищувати `visitsCountMap`, коли ми видаляємо користувачів, інакше він буде рости в пам'яті необмежено довго. Таке очищення може стати нудним завданням у складних архітектурах.
 
 Ми можемо уникнути цього, перейшовши на `WeakMap`:
 
@@ -166,11 +166,11 @@ function countUser(user) {
 }
 ```
 
-Тепер ми не повинні очищати `visitsCountMap`. Після того, як об’єкт `john` стає недоступним будь-яким способом, за винятком того, як ключ `WeakMap`, він видаляється з пам’яті, разом з інформацією за цим ключем в `WeakMap`.
+Тепер ми не повинні очищати `visitsCountMap`. Після того, як об'єкт `john` стає недоступним будь-яким способом, за винятком того, як ключ `WeakMap`, він видаляється з пам'яті, разом з інформацією за цим ключем в `WeakMap`.
 
 ## Приклад використання: кешування
 
-Іншим загальним прикладом є кешування. Ми можемо зберігати ("кеш") результати з функції, щоб майбутні виклики на тому ж об’єкті могли повторно використовувати його.
+Іншим загальним прикладом є кешування. Ми можемо зберігати ("кеш") результати з функції, щоб майбутні виклики на тому ж об'єкті могли повторно використовувати його.
 
 Щоб досягти цього, ми можемо використовувати `Map` (не оптимальний сценарій):
 
@@ -178,7 +178,7 @@ function countUser(user) {
 // 📁 cache.js
 let cache = new Map();
 
-// обчислити та запам’ятати результат
+// обчислити та запам'ятати результат
 function process(obj) {
   if (!cache.has(obj)) {
     let result = /* розрахунки результату для */ obj;
@@ -195,22 +195,22 @@ function process(obj) {
 */!*
 
 // 📁 main.js
-let obj = {/* скажімо, у нас є об’єкт */};
+let obj = {/* скажімо, у нас є об'єкт */};
 
 let result1 = process(obj); // розраховано
 
 // ...пізніше, з іншого місця в коді...
-let result2 = process(obj); // запам’ятований результат, взятий з кешу
+let result2 = process(obj); // запам'ятований результат, взятий з кешу
 
-// ...пізніше, коли об’єкт більше не потрібний:
+// ...пізніше, коли об'єкт більше не потрібний:
 obj = null;
 
-alert(cache.size); // 1 (Ой! Об’єкт досі в кеші і займає пам’ять!)
+alert(cache.size); // 1 (Ой! Об'єкт досі в кеші і займає пам'ять!)
 ```
 
-Для багаторазових викликів `process(obj)` з тим самим об’єктом він лише обчислює результат вперше, а потім просто бере його з `cache`. Недоліком є те, що нам потрібно чистити `cache`, коли об’єкт більше не потрібний.
+Для багаторазових викликів `process(obj)` з тим самим об'єктом він лише обчислює результат вперше, а потім просто бере його з `cache`. Недоліком є те, що нам потрібно чистити `cache`, коли об'єкт більше не потрібний.
 
-Якщо ми замінимо `Map` на `WeakMap`, то ця проблема зникає. Кешований результат буде видалено з пам’яті автоматично після того, як об’єкт видаляється збирачем сміття.
+Якщо ми замінимо `Map` на `WeakMap`, то ця проблема зникає. Кешований результат буде видалено з пам'яті автоматично після того, як об'єкт видаляється збирачем сміття.
 
 ```js run
 // 📁 cache.js
@@ -218,7 +218,7 @@ alert(cache.size); // 1 (Ой! Об’єкт досі в кеші і займа
 let cache = new WeakMap();
 */!*
 
-// обчислити та запам’ятати результат
+// обчислити та запам'ятати результат
 function process(obj) {
   if (!cache.has(obj)) {
     let result = /* розрахувати результат для */ obj;
@@ -231,12 +231,12 @@ function process(obj) {
 }
 
 // 📁 main.js
-let obj = {/* якийсь об’єкт */};
+let obj = {/* якийсь об'єкт */};
 
 let result1 = process(obj);
 let result2 = process(obj);
 
-// ...пізніше, коли об’єкт більше не потрібний:
+// ...пізніше, коли об'єкт більше не потрібний:
 obj = null;
 
 // Не можна отримати cache.size тому, що це WeakMap,
@@ -248,11 +248,11 @@ obj = null;
 
 [`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) поводитися аналогічно:
 
-- Це аналог `Set`, але ми можемо додати лише об’єкти до `WeakSet` (не примітиви).
-- Об’єкт існує в наборі, коли він доступний з де-небудь ще.
+- Це аналог `Set`, але ми можемо додати лише об'єкти до `WeakSet` (не примітиви).
+- Об'єкт існує в наборі, коли він доступний з де-небудь ще.
 - Так само як `Set`, він підтримує [`add`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Weakset/add), [`has`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Weakset/has) і [`delete`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Weakset/delete), але не підтримує `size`, `keys()` та ітерацію.
 
-Будучи "слабким", він також служить зберігання додаткових даних. Але не для довільних даних, а для фактів "так/ні". Приналежність до `WeakSet` може означати щось про об’єкт.
+Будучи "слабким", він також служить зберігання додаткових даних. Але не для довільних даних, а для фактів "так/ні". Приналежність до `WeakSet` може означати щось про об'єкт.
 
 Наприклад, ми можемо додати користувачів до `WeakSet`, щоб відстежувати тих, хто відвідав наш сайт:
 
@@ -280,16 +280,16 @@ john = null;
 // visitedSet буде очищено автоматично
 ```
 
-Найбільш помітним обмеженням `WeakMap` та `WeakSet` є відсутність ітерацій та нездатність отримати весь поточний вміст. Це може виявитися незручним, але не перешкоджає `WeakMap/WeakSet` виконувати свою основну роботу -- бути «додатковим» сховищем даних для об’єктів, які зберігаються/управляються в іншому місці.
+Найбільш помітним обмеженням `WeakMap` та `WeakSet` є відсутність ітерацій та нездатність отримати весь поточний вміст. Це може виявитися незручним, але не перешкоджає `WeakMap/WeakSet` виконувати свою основну роботу -- бути «додатковим» сховищем даних для об'єктів, які зберігаються/управляються в іншому місці.
 
 ## Підсумки
 
-[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- це подібна до `Map` колекція, яка дозволяє використовувати лише об’єкти, як ключі і видаляє їх разом з пов’язаним значенням, коли вони стануть недоступними іншим засобам.
+[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) -- це подібна до `Map` колекція, яка дозволяє використовувати лише об'єкти, як ключі і видаляє їх разом з пов'язаним значенням, коли вони стануть недоступними іншим засобам.
 
-[`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) -- це подібна до `Set` колекція, яка зберігає тільки об’єкти та видаляє їх після того, як вони стануть недоступними іншим засобам.
+[`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) -- це подібна до `Set` колекція, яка зберігає тільки об'єкти та видаляє їх після того, як вони стануть недоступними іншим засобам.
 
-Їх основна перевага полягає у тому, що вони мають слабке посилання на об’єкти, тому вони можуть бути легко видаленими збирачем сміття.
+Їх основна перевага полягає у тому, що вони мають слабке посилання на об'єкти, тому вони можуть бути легко видаленими збирачем сміття.
 
 Це досягається внаслідок відсутності підтримки `clear`, `size`, `keys`, `values`...
 
-`WeakMap` та `WeakSet` використовуються як "вторинні" структури даних, на додаток до "первинного" сховища об’єктів. Після того, як об’єкт видаляється з первинного сховища, якщо він виявляється лише як ключ `WeakMap` або в `WeakSet`, він буде очищений автоматично.
+`WeakMap` та `WeakSet` використовуються як "вторинні" структури даних, на додаток до "первинного" сховища об'єктів. Після того, як об'єкт видаляється з первинного сховища, якщо він виявляється лише як ключ `WeakMap` або в `WeakSet`, він буде очищений автоматично.
diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md
index 2ce08b4c7..c4ec6b490 100644
--- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md
+++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md
@@ -4,11 +4,11 @@ importance: 5
 
 # Підсумуйте властивості
 
-Є об’єкт `salaries` з довільною кількістю властивостей, що містять заробітні плати. 
+Є об'єкт `salaries` з довільною кількістю властивостей, що містять заробітні плати. 
 
 Напишіть функцію `sumSalaries(salaries)`, що повертає суму всіх зарплат за допомогою `Object.values` та циклу`for..of`.
 
-Якщо об’єкт `salaries` порожній, тоді результат повинен бути `0`.
+Якщо об'єкт `salaries` порожній, тоді результат повинен бути `0`.
 
 Наприклад:
 
diff --git a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md
index fbf811df4..94bf3a841 100644
--- a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md
+++ b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Порахуйте властивості
 
-Напишіть функцію `count(obj)`, що повертає кількість властивостей об’єкта:
+Напишіть функцію `count(obj)`, що повертає кількість властивостей об'єкта:
 
 ```js
 let user = {
diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md
index 2e0bab1b0..bbd64172f 100644
--- a/1-js/05-data-types/09-keys-values-entries/article.md
+++ b/1-js/05-data-types/09-keys-values-entries/article.md
@@ -13,11 +13,11 @@
 - `Set`
 - `Array`
 
-Звичайні об’єкти також підтримують подібні методи, але синтаксис дещо інший.
+Звичайні об'єкти також підтримують подібні методи, але синтаксис дещо інший.
 
 ## Object.keys, values, entries
 
-Для простих об’єктів доступні наступні методи:
+Для простих об'єктів доступні наступні методи:
 
 - [Object.keys(obj)](mdn:js/Object/keys) -- повертає масив ключів.
 - [Object.values(obj)](mdn:js/Object/values) -- повертає масив значень.
@@ -32,9 +32,9 @@
 
 Перша відмінність полягає в тому, що ми повинні викликати `Object.keys(obj)`, а не `obj.keys()`.
 
-Чому так? Основною причиною цього є гнучкість. Пам’ятайте, об’єкти є базою всіх складних структур у JavaScript. Ми можемо мати власний об’єкт, такий як `data`, який реалізує власний метод `data.values()`. І ми все ще можемо застосовувати до нього `Object.values(data)`.
+Чому так? Основною причиною цього є гнучкість. Пам'ятайте, об'єкти є базою всіх складних структур у JavaScript. Ми можемо мати власний об'єкт, такий як `data`, який реалізує власний метод `data.values()`. І ми все ще можемо застосовувати до нього `Object.values(data)`.
 
-Друга відмінність полягає в тому, що `Object.*` методи повертають "реальний" масив об’єктів, а не просто ітерабельний. Це переважно з історичних причин.
+Друга відмінність полягає в тому, що `Object.*` методи повертають "реальний" масив об'єктів, а не просто ітерабельний. Це переважно з історичних причин.
 
 Наприклад:
 
@@ -70,17 +70,17 @@ for (let value of Object.values(user)) {
 ```
 
 
-## Трансформація об’єктів
+## Трансформація об'єктів
 
-У об’єктів немає багатьох методів, які є у масивів, наприклад `map`, `filter` та інші.
+У об'єктів немає багатьох методів, які є у масивів, наприклад `map`, `filter` та інші.
 
 Якщо б ми хотіли їх застосувати, тоді б ми використовували `Object.entries` з подальшим викликом `Object.fromEntries`:
 
 1. Викликаємо `Object.entries(obj)`, щоб отримати масив пар ключ/значення з `obj`.
 2. На ньому використовуємо методи масиву, наприклад `map`, щоб перетворити ці пари ключів/значень.
-3. Використаємо `Object.fromEntries(array)` на отриманому масиві, щоб перетворити його знову на об’єкт.
+3. Використаємо `Object.fromEntries(array)` на отриманому масиві, щоб перетворити його знову на об'єкт.
 
-Наприклад, у нас є об’єкт з цінами, і ми б хотіли їх подвоїти:
+Наприклад, у нас є об'єкт з цінами, і ми б хотіли їх подвоїти:
 
 ```js run
 let prices = {
@@ -92,7 +92,7 @@ let prices = {
 *!*
 let doublePrices = Object.fromEntries(
   // перетворити ціни на масив, потім застосувати map, щоб перетворити на пари ключ/значення
-  // а потім fromEntries повертає об’єкт
+  // а потім fromEntries повертає об'єкт
   Object.entries(prices).map(entry => [entry[0], entry[1] * 2])
 );
 */!*
diff --git a/1-js/05-data-types/10-destructuring-assignment/1-destruct-user/task.md b/1-js/05-data-types/10-destructuring-assignment/1-destruct-user/task.md
index f4d9741e1..129be4a24 100644
--- a/1-js/05-data-types/10-destructuring-assignment/1-destruct-user/task.md
+++ b/1-js/05-data-types/10-destructuring-assignment/1-destruct-user/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Деструктуроване присвоєння
 
-У нас є об’єкт:
+У нас є об'єкт:
 
 ```js
 let user = {
diff --git a/1-js/05-data-types/10-destructuring-assignment/6-max-salary/task.md b/1-js/05-data-types/10-destructuring-assignment/6-max-salary/task.md
index 23adc8601..71edd9475 100644
--- a/1-js/05-data-types/10-destructuring-assignment/6-max-salary/task.md
+++ b/1-js/05-data-types/10-destructuring-assignment/6-max-salary/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Максимальна зарплата 
 
-Є об’єкт `salaries`:
+Є об'єкт `salaries`:
 
 ```js
 let salaries = {
@@ -14,9 +14,9 @@ let salaries = {
 };
 ```
 
-Створіть функцію `topSalary(salaries)` яка повертає ім’я найбільш високооплачуваної особи.
+Створіть функцію `topSalary(salaries)` яка повертає ім'я найбільш високооплачуваної особи.
 
-- Якщо об’єкт `salaries` пустий, функція повинна повернути `null`.
+- Якщо об'єкт `salaries` пустий, функція повинна повернути `null`.
 - Якщо є кілька високооплачуваних осіб, поверніть будь-якого з них.
 
 P.S. Використовуйте `Object.entries` і деструктурування для перебору пар ключ/значення.
diff --git a/1-js/05-data-types/10-destructuring-assignment/article.md b/1-js/05-data-types/10-destructuring-assignment/article.md
index f438da60e..ec3f18841 100644
--- a/1-js/05-data-types/10-destructuring-assignment/article.md
+++ b/1-js/05-data-types/10-destructuring-assignment/article.md
@@ -2,12 +2,12 @@
 
 Двома найбільш вживаними структурами даних у JavaScript є `Object` та `Array`.
 
-- Об’єкти дозволяють нам створити єдину сутність, яка зберігатиме дані за ключем. 
+- Об'єкти дозволяють нам створити єдину сутність, яка зберігатиме дані за ключем. 
 - Масиви дозволяють нам зібрати елементи даних у впорядкований список.
 
-Хоча, коли ми передаємо їх у функції, їй може знадобитися не об’єкт/масив в цілому, а тільки окремі їх елементи.
+Хоча, коли ми передаємо їх у функції, їй може знадобитися не об'єкт/масив в цілому, а тільки окремі їх елементи.
 
-*Деструктуроване присвоєння* -- це спеціальний синтаксис, що дозволяє нам "розпаковувати" масиви чи об’єкти в купу змінних, оскільки іноді це зручніше.
+*Деструктуроване присвоєння* -- це спеціальний синтаксис, що дозволяє нам "розпаковувати" масиви чи об'єкти в купу змінних, оскільки іноді це зручніше.
 
 Деструктурування також чудово працює зі складними функціями, які мають багато параметрів, типових значень тощо. Незабаром ми це побачимо.
 
@@ -88,7 +88,7 @@ let [one, two, three] = new Set([1, 2, 3]);
 ````smart header="Цикл з .entries()"
 У попередньому розділі ми бачили метод [Object.entries(obj)](mdn:js/Object/entries).
 
-Ми можемо використовувати його з деструктуруванням для циклічного перебору ключів-та-значень об’єкта:
+Ми можемо використовувати його з деструктуруванням для циклічного перебору ключів-та-значень об'єкта:
 
 ```js run
 let user = {
@@ -210,9 +210,9 @@ alert(surname); // значення, отримане з prompt
 
 Зверніть увагу: `prompt` буде спрацьовувати лише для відсутнього значення (`surname`).
 
-## Деструктурування об’єктів
+## Деструктурування об'єктів
 
-Деструктуроване присвоєння також працює з об’єктами.
+Деструктуроване присвоєння також працює з об'єктами.
 
 Основний синтаксис такий:
 
@@ -220,7 +220,7 @@ alert(surname); // значення, отримане з prompt
 let {var1, var2} = {var1:…, var2:…}
 ```
 
-Ми повинні мати існуючий об’єкт праворуч, який ми хочемо розділити на змінні. Ліва частина містить об’єктоподібний "шаблон" для відповідних властивостей. У найпростішому випадку це список імен змінних у `{...}`.
+Ми повинні мати існуючий об'єкт праворуч, який ми хочемо розділити на змінні. Ліва частина містить об'єктоподібний "шаблон" для відповідних властивостей. У найпростішому випадку це список імен змінних у `{...}`.
 
 Наприклад:
 
@@ -251,7 +251,7 @@ let {height, width, title} = { title: "Меню", height: 200, width: 100 }
 
 Шаблон з лівого боку може бути більш складним і визначати зіставлення властивостей та змінних.
 
-Якщо ми хочемо присвоїти властивість змінній з іншим іменем, наприклад, зробити так, щоб `options.width` переходив до змінної з назвою `w`, то ми можемо встановити ім’я змінної за допомогою двокрапки:
+Якщо ми хочемо присвоїти властивість змінній з іншим іменем, наприклад, зробити так, щоб `options.width` переходив до змінної з назвою `w`, то ми можемо встановити ім'я змінної за допомогою двокрапки:
 
 ```js run
 let options = {
@@ -325,7 +325,7 @@ alert(w);      // 100
 alert(h);      // 200
 ```
 
-Якщо у нас є складний об’єкт з багатьма властивостями, ми можемо витягти лише те, що нам потрібно:
+Якщо у нас є складний об'єкт з багатьма властивостями, ми можемо витягти лише те, що нам потрібно:
 
 ```js run
 let options = {
@@ -340,9 +340,9 @@ let { title } = options;
 alert(title); // Меню
 ```
 
-### Залишок об’єкту "..."
+### Залишок об'єкту "..."
 
-Що робити, якщо об’єкт має більше властивостей, ніж ми маємо змінних? Чи можемо ми взяти частину, а потім призначити кудись «залишок»?
+Що робити, якщо об'єкт має більше властивостей, ніж ми маємо змінних? Чи можемо ми взяти частину, а потім призначити кудись «залишок»?
 
 Ми можемо використовувати шаблон залишкового оператору, так само, як ми робили з масивами. Він не підтримується деякими старішими браузерами (IE, використовуйте Babel для поліфілу), але працює в сучасних.
 
@@ -357,7 +357,7 @@ let options = {
 
 *!*
 // title = властивість з назвою title
-// rest = об’єкт з залишковими властивостями
+// rest = об'єкт з залишковими властивостями
 let {title, ...rest} = options;
 */!*
 
@@ -404,9 +404,9 @@ alert( title ); // Меню
 
 ## Вкладене деструктурування
 
-Якщо об’єкт або масив містять інші вкладені об’єкти та масиви, ми можемо використовувати більш складні шаблони з лівого боку для вилучення більш глибоких частин.
+Якщо об'єкт або масив містять інші вкладені об'єкти та масиви, ми можемо використовувати більш складні шаблони з лівого боку для вилучення більш глибоких частин.
 
-У наведеному нижче коді `options` містить інший об’єкт у властивості `size` та масив у властивості `items`. Шаблон у лівій частині присвоєння має ту саму структуру для вилучення з них значень:
+У наведеному нижче коді `options` містить інший об'єкт у властивості `size` та масив у властивості `items`. Шаблон у лівій частині присвоєння має ту саму структуру для вилучення з них значень:
 
 ```js run
 let options = {
@@ -425,7 +425,7 @@ let {
     height
   },
   items: [item1, item2], // тут призначимо items
-  title = "Меню" // немає в об’єкті (використовується типове значення)
+  title = "Меню" // немає в об'єкті (використовується типове значення)
 } = options;
 
 alert(title);  // Меню
@@ -435,7 +435,7 @@ alert(item1);  // Торт
 alert(item2);  // Пончик
 ```
 
-Усі властивості об’єкта `options`, окрім `extra`, яке відсутнє у лівій частині, призначаються відповідним змінним:
+Усі властивості об'єкта `options`, окрім `extra`, яке відсутнє у лівій частині, призначаються відповідним змінним:
 
 ![](destructuring-complex.svg)
 
@@ -445,7 +445,7 @@ alert(item2);  // Пончик
 
 ## Розумні параметри функції
 
-Бувають випадки, коли функція має багато параметрів, більшість з яких є необов’язковими. Особливо це стосується користувацьких інтерфейсів. Уявіть собі функцію, яка створює меню. Вона може мати ширину, висоту, назву, список елементів тощо.
+Бувають випадки, коли функція має багато параметрів, більшість з яких є необов'язковими. Особливо це стосується користувацьких інтерфейсів. Уявіть собі функцію, яка створює меню. Вона може мати ширину, висоту, назву, список елементів тощо.
 
 Нижче наведено поганий спосіб написати таку функцію:
 
@@ -455,7 +455,7 @@ function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
 }
 ```
 
-У реальному житті проблема полягає в тому, як запам’ятати порядок аргументів. Зазвичай IDE намагаються нам допомогти, особливо якщо код добре задокументований, але все ж... Інша проблема полягає в тому, як викликати функцію, коли більшість параметрів типово в порядку.
+У реальному житті проблема полягає в тому, як запам'ятати порядок аргументів. Зазвичай IDE намагаються нам допомогти, особливо якщо код добре задокументований, але все ж... Інша проблема полягає в тому, як викликати функцію, коли більшість параметрів типово в порядку.
 
 Можливо так?
 
@@ -468,10 +468,10 @@ showMenu("My Menu", undefined, undefined, ["Item1", "Item2"])
 
 На допомогу приходить деструктурування!
 
-Ми можемо передати параметри як об’єкт, і функція негайно деструктурує їх на змінні:
+Ми можемо передати параметри як об'єкт, і функція негайно деструктурує їх на змінні:
 
 ```js run
-// ми передаємо об’єкт до функції
+// ми передаємо об'єкт до функції
 let options = {
   title: "My menu",
   items: ["Item1", "Item2"]
@@ -488,7 +488,7 @@ function showMenu(*!*{title = "Untitled", width = 200, height = 100, items = []}
 showMenu(options);
 ```
 
-Ми також можемо використовувати більш складне деструктурування з вкладеними об’єктами та двокрапками:
+Ми також можемо використовувати більш складне деструктурування з вкладеними об'єктами та двокрапками:
 
 ```js run
 let options = {
@@ -520,9 +520,9 @@ function({
 })
 ```
 
-Тоді для об’єкта параметрів буде змінна `varName` для властивості `incomingProperty` з типовим значенням `defaultValue`.
+Тоді для об'єкта параметрів буде змінна `varName` для властивості `incomingProperty` з типовим значенням `defaultValue`.
 
-Зверніть увагу, що таке деструктурування передбачає, що `showMenu()` має аргумент. Якщо ми хочемо, щоб усі значення були типовими, ми повинні вказати порожній об’єкт:
+Зверніть увагу, що таке деструктурування передбачає, що `showMenu()` має аргумент. Якщо ми хочемо, щоб усі значення були типовими, ми повинні вказати порожній об'єкт:
 
 ```js
 showMenu({}); // так добре, усі значення типові
@@ -530,7 +530,7 @@ showMenu({}); // так добре, усі значення типові
 showMenu(); // це дасть помилку
 ```
 
-Ми можемо виправити це, зробивши `{}` типовим значенням для всього об’єкта параметрів:
+Ми можемо виправити це, зробивши `{}` типовим значенням для всього об'єкта параметрів:
 
 ```js run
 function showMenu({ title = "Menu", width = 100, height = 200 }*!* = {}*/!*) {
@@ -540,19 +540,19 @@ function showMenu({ title = "Menu", width = 100, height = 200 }*!* = {}*/!*) {
 showMenu(); // Menu 100 200
 ```
 
-У наведеному вище коді весь об’єкт аргументів є типовим значенням `{}`, тому завжди є що деструктурувати.
+У наведеному вище коді весь об'єкт аргументів є типовим значенням `{}`, тому завжди є що деструктурувати.
 
 ## Підсумки
 
-- Деструктуруване присвоєння дозволяє миттєво зіставити об’єкт або масив з багатьма змінними.
-- Повний синтаксис для об’єкта:
+- Деструктуруване присвоєння дозволяє миттєво зіставити об'єкт або масив з багатьма змінними.
+- Повний синтаксис для об'єкта:
     ```js
     let {prop : varName = default, ...rest} = object
     ```
 
     Це означає, що властивість `prop` має входити до змінної `varName` і, якщо такої властивості не існує, слід використовувати `типове значення`.
 
-    Властивості об’єкта, які не мають зіставлення, копіюються в об’єкт `rest`.
+    Властивості об'єкта, які не мають зіставлення, копіюються в об'єкт `rest`.
 
 - Повний синтаксис для масиву:
 
@@ -562,4 +562,4 @@ showMenu(); // Menu 100 200
 
     Перший елемент переходить до `item1`; другий переходить до `item2`, усі інші утворюють масив `rest`.
 
-- Можна витягувати дані з вкладених масивів/об’єктів, для цього ліва сторона повинна мати ту ж структуру, що й права.
+- Можна витягувати дані з вкладених масивів/об'єктів, для цього ліва сторона повинна мати ту ж структуру, що й права.
diff --git a/1-js/05-data-types/11-date/1-new-date/solution.md b/1-js/05-data-types/11-date/1-new-date/solution.md
index 6b7710198..46f97e388 100644
--- a/1-js/05-data-types/11-date/1-new-date/solution.md
+++ b/1-js/05-data-types/11-date/1-new-date/solution.md
@@ -1,4 +1,4 @@
-Конструктор `new Date` використовує місцевий часовий пояс. Отже, єдина важлива річ, яку слід пам’ятати це те, що місяці починаються з нуля.
+Конструктор `new Date` використовує місцевий часовий пояс. Отже, єдина важлива річ, яку слід пам'ятати це те, що місяці починаються з нуля.
 
 Тому лютий має номер 1.
 
diff --git a/1-js/05-data-types/11-date/1-new-date/task.md b/1-js/05-data-types/11-date/1-new-date/task.md
index 98f5951b8..d870e98aa 100644
--- a/1-js/05-data-types/11-date/1-new-date/task.md
+++ b/1-js/05-data-types/11-date/1-new-date/task.md
@@ -4,6 +4,6 @@ importance: 5
 
 # Створити дату
 
-Створити об’єкт `Date` на дату: 20 лютого 2012, 3:12 ранку. Часовий пояс є місцевим.
+Створити об'єкт `Date` на дату: 20 лютого 2012, 3:12 ранку. Часовий пояс є місцевим.
 
 Показати його за допомогою `alert`.
diff --git a/1-js/05-data-types/11-date/6-get-seconds-today/solution.md b/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
index 80b7f980f..f3d44826c 100644
--- a/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
+++ b/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
@@ -6,7 +6,7 @@
 function getSecondsToday() {
   let now = new Date();
 
-  // створити об’єкт, використовуючи поточний день/місяць/рік
+  // створити об'єкт, використовуючи поточний день/місяць/рік
   let today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
 
   let diff = now - today; // мс різниця
diff --git a/1-js/05-data-types/11-date/8-format-date-relative/solution.md b/1-js/05-data-types/11-date/8-format-date-relative/solution.md
index 70def4ca5..653cf9c7b 100644
--- a/1-js/05-data-types/11-date/8-format-date-relative/solution.md
+++ b/1-js/05-data-types/11-date/8-format-date-relative/solution.md
@@ -30,7 +30,7 @@ function formatDate(date) {
     '0' + d.getMinutes()
   ].map(component => component.slice(-2)); // отримати останні 2 цифри кожного компоненту
 
-  // з’єднати компоненти в дату
+  // з'єднати компоненти в дату
   return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
 }
 
diff --git a/1-js/05-data-types/11-date/article.md b/1-js/05-data-types/11-date/article.md
index 33024e8f4..779f09b91 100644
--- a/1-js/05-data-types/11-date/article.md
+++ b/1-js/05-data-types/11-date/article.md
@@ -1,15 +1,15 @@
 # Дата і час
 
-Познайомтеся з новим вбудованим об’єктом: [Date](mdn:js/Date). Він зберігає дату, час і надає методи для управління датою/часом.
+Познайомтеся з новим вбудованим об'єктом: [Date](mdn:js/Date). Він зберігає дату, час і надає методи для управління датою/часом.
 
 Наприклад, ми можемо використовувати його для зберігання часу створення/модифікації, щоб виміряти час, або просто для друку поточної дати.
 
 ## Створення
 
-Щоб створити новий об’єкт `Date` викличемо `new Date()` з одним з наступних аргументів:
+Щоб створити новий об'єкт `Date` викличемо `new Date()` з одним з наступних аргументів:
 
 `new Date()`
-: Без аргументів -- створює об’єкт `Date` для поточної дати та часу:
+: Без аргументів -- створює об'єкт `Date` для поточної дати та часу:
 
     ```js run
     let now = new Date();
@@ -17,7 +17,7 @@
     ```
 
 `new Date(milliseconds)`
-: Створює об’єкт `Date` з часом, що дорівнює кількості мілісекунд (1/1000 секунди), що минули після 1 січня 1970 UTC+0.
+: Створює об'єкт `Date` з часом, що дорівнює кількості мілісекунд (1/1000 секунди), що минули після 1 січня 1970 UTC+0.
 
     ```js run
     // 0 означає 01.01.1970 UTC+0
@@ -31,7 +31,7 @@
 
     Ціле число, яке являє собою кількість мілісекунд, що пройшли з початку 1970 року, називається міткою часу (*timestamp*).
 
-    Це легке числове представлення дати. Ми завжди можемо створити дату з timestamp за допомогою `new Date(timestamp)` і перетворити об’єкт `Date`, що існує, до timestamp за допомогою методу `date.getTime()` (див. нижче).
+    Це легке числове представлення дати. Ми завжди можемо створити дату з timestamp за допомогою `new Date(timestamp)` і перетворити об'єкт `Date`, що існує, до timestamp за допомогою методу `date.getTime()` (див. нижче).
 
     Дати до 01.01.1970 р. мають негативний timestamp, наприклад:
     ```js run
@@ -55,7 +55,7 @@
     ```
 
 `new Date(year, month, date, hours, minutes, seconds, ms)`
-: Створює дату з заданими компонентами у місцевому часовому поясі. Тільки перші два аргументи обов’язкові.
+: Створює дату з заданими компонентами у місцевому часовому поясі. Тільки перші два аргументи обов'язкові.
 
     - `year` має містити 4 цифри. Для сумісності також допускаються 2 цифри, які вважаються `19xx`, напр. `98` тут те саме, що й `1998`, але настійно рекомендується завжди використовувати 4 цифри.
     - Рахунок місяців починається з `0` (січня), до `11` (грудня).
@@ -78,7 +78,7 @@
 
 ## Доступ до компонентів дати 
 
-Існують методи доступу до року, місяця і так далі з об’єкта `Date`:
+Існують методи доступу до року, місяця і так далі з об'єкта `Date`:
 
 [getFullYear()](mdn:js/Date/getFullYear)
 : Отримати рік (4 цифри)
@@ -164,7 +164,7 @@ alert(today); // ще сьогодні, зараз рівно 00:00:00.
 
 ## Автокорекція
 
-*Автокорекція* -- це дуже зручна особливість об’єктів `Date`. Ми можемо встановити данні за межами діапазону, і вони будуть автоматично налаштувати себе.
+*Автокорекція* -- це дуже зручна особливість об'єктів `Date`. Ми можемо встановити данні за межами діапазону, і вони будуть автоматично налаштувати себе.
 
 Наприклад:
 
@@ -175,7 +175,7 @@ alert(date); // ...це 1 лютого 2013!
 
 Компоненти поза межами діапазону розподіляються автоматично.
 
-Скажімо, нам потрібно збільшити дату "28 лютого 2016" на 2 дні. Це може бути "2 березня" або "1 березня" у випадку високосного року. Нам не потрібно думати про це. Просто додайте 2 дні. Об’єкт `Date` зробить все інше:
+Скажімо, нам потрібно збільшити дату "28 лютого 2016" на 2 дні. Це може бути "2 березня" або "1 березня" у випадку високосного року. Нам не потрібно думати про це. Просто додайте 2 дні. Об'єкт `Date` зробить все інше:
 
 ```js run
 let date = new Date(2016, 1, 28);
@@ -209,7 +209,7 @@ alert( date ); // 31 грудня 2015
 
 ## Перетворення дати до числа, різниця дат
 
-Коли `Date` об’єкт перетворюється на номер, він стає timestamp так само, як `date.getTime()`:
+Коли `Date` об'єкт перетворюється на номер, він стає timestamp так само, як `date.getTime()`:
 
 ```js run
 let date = new Date();
@@ -235,11 +235,11 @@ alert( `Цикл зайняв ${end - start} мс` );
 
 ## Date.now()
 
-Якщо ми хочемо тільки виміряти час, нам не потрібен об’єкт `Date`.
+Якщо ми хочемо тільки виміряти час, нам не потрібен об'єкт `Date`.
 
 Існує спеціальний метод `Date.now()`, що повертає поточний timestamp.
 
-Це семантично еквівалентно до `new Date().getTime()`, але не створює проміжного об’єкта `Date`. Так що цей підхід працює швидше і не навантажує збирач сміття.
+Це семантично еквівалентно до `new Date().getTime()`, але не створює проміжного об'єкта `Date`. Так що цей підхід працює швидше і не навантажує збирач сміття.
 
 Він використовується в основному для зручності або коли важлива продуктивність, як в іграх на JavaScript або інших спеціалізованих застосунках.
 
@@ -388,7 +388,7 @@ for (let i = 0; i < 10; i++) {
 - `YYYY-MM-DD` -- це дата: рік-місяць-день.
 - Символ `"T"` використовується як роздільник.
 - `HH:mm:ss.sss` -- це час: години, хвилини, секунди і мілісекунди.
-- Необов’язкова частина `'Z'` позначає часовий пояс у форматі `+-hh:mm`. Одинична буква `Z` буде означати UTC+0.
+- Необов'язкова частина `'Z'` позначає часовий пояс у форматі `+-hh:mm`. Одинична буква `Z` буде означати UTC+0.
 
 Коротші варіанти також можливі, як `YYYY-MM-DD` або `YYYY-MM` або навіть `YYYY`.
 
@@ -402,7 +402,7 @@ let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
 alert(ms); // 1327611110417  (timestamp)
 ```
 
-Ми можемо миттєво створити об’єкт за допомогою `new Date` з timestamp:
+Ми можемо миттєво створити об'єкт за допомогою `new Date` з timestamp:
 
 ```js run
 let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
@@ -412,7 +412,7 @@ alert(date);
 
 ## Підсумки
 
-- Дата та час у JavaScript представлені об’єктом [Date](mdn:js/Date). Ми не можемо створити "тільки дату" або "тільки час": об’єкти `Date` завжди несуть в собі обидва значення.
+- Дата та час у JavaScript представлені об'єктом [Date](mdn:js/Date). Ми не можемо створити "тільки дату" або "тільки час": об'єкти `Date` завжди несуть в собі обидва значення.
 - Місяці рахуються з нуля (так, січень -- це нульовий місяць).
 - Дні тижня в `getDay()` також рахуються з нуля (з неділі).
 - `Date` автоматично виправляє себе, коли встановлено компоненти, які виходять за межі. Це добре для додавання/віднімання днів/місяців/годин.
diff --git a/1-js/05-data-types/12-json/1-serialize-object/task.md b/1-js/05-data-types/12-json/1-serialize-object/task.md
index 8c5dd3a30..6ffd32406 100644
--- a/1-js/05-data-types/12-json/1-serialize-object/task.md
+++ b/1-js/05-data-types/12-json/1-serialize-object/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Перетворіть об’єкт в JSON і назад
+# Перетворіть об'єкт в JSON і назад
 
 Перетворіть `user` на JSON, після цього зробіть з нього знову об'єкт і запишіть його в іншу змінну.
 
diff --git a/1-js/05-data-types/12-json/2-serialize-event-circular/task.md b/1-js/05-data-types/12-json/2-serialize-event-circular/task.md
index 1664e65a9..101b1b5c0 100644
--- a/1-js/05-data-types/12-json/2-serialize-event-circular/task.md
+++ b/1-js/05-data-types/12-json/2-serialize-event-circular/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Виключити зворотні посилання
 
-У простих випадках циклічних посиланнь ми можемо виключити від серіалізації властивість, через яку воно виникло, за її ім’ям.
+У простих випадках циклічних посиланнь ми можемо виключити від серіалізації властивість, через яку воно виникло, за її ім'ям.
 
 Але іноді ми не можемо просто використовувати назву, оскільки вона може використовуватися як і у циклічних посиланнях, так і в звичайних, потрібних нам, властивостях. Таким чином, ми можемо перевірити властивість за її значенням.
 
diff --git a/1-js/05-data-types/12-json/article.md b/1-js/05-data-types/12-json/article.md
index 971fcb695..9266c1ad8 100644
--- a/1-js/05-data-types/12-json/article.md
+++ b/1-js/05-data-types/12-json/article.md
@@ -1,6 +1,6 @@
 # Методи JSON, toJSON
 
-Скажімо, у нас є складний об’єкт, і ми хотіли б перетворити його в рядок, щоб відправити його через мережу або просто вивести його для логування.
+Скажімо, у нас є складний об'єкт, і ми хотіли б перетворити його в рядок, щоб відправити його через мережу або просто вивести його для логування.
 
 Безумовно, такий рядок повинен включати всі важливі властивості.
 
@@ -21,18 +21,18 @@ let user = {
 alert(user); // {name: "Іван", age: 30}
 ```
 
-... Але в процесі розробки додаються нові властивості, старі властивості перейменовуються та видаляються. Оновлення такого `toString` кожен раз може стати проблемою. Ми могли б спробувати перебрати властивості в ньому, але що, якщо об’єкт є складним і в його властивостях є вкладені об’єкти? Ми також повинні реалізувати їх перетворення.
+... Але в процесі розробки додаються нові властивості, старі властивості перейменовуються та видаляються. Оновлення такого `toString` кожен раз може стати проблемою. Ми могли б спробувати перебрати властивості в ньому, але що, якщо об'єкт є складним і в його властивостях є вкладені об'єкти? Ми також повинні реалізувати їх перетворення.
 
 На щастя, нема потреби писати код для обробки всього цього. У цьго завдання є просте рішення.
 
 ## JSON.stringify
 
-[JSON](https://uk.wikipedia.org/wiki/JSON) (JavaScript Object Notation) -- це загальний формат, який представляє значення та об’єкти. Він описується у [стандарті RFC 4627](https://datatracker.ietf.org/doc/html/rfc4627). Спочатку він був розроблений для JavaScript, але багато інших мов мають бібліотеки, для його обробки. Тому легко використовувати JSON для обміну даними, коли клієнт використовує JavaScript, а сервер написаний на Ruby/PHP/Java тощо.
+[JSON](https://uk.wikipedia.org/wiki/JSON) (JavaScript Object Notation) -- це загальний формат, який представляє значення та об'єкти. Він описується у [стандарті RFC 4627](https://datatracker.ietf.org/doc/html/rfc4627). Спочатку він був розроблений для JavaScript, але багато інших мов мають бібліотеки, для його обробки. Тому легко використовувати JSON для обміну даними, коли клієнт використовує JavaScript, а сервер написаний на Ruby/PHP/Java тощо.
 
 JavaScript надає методи:
 
-- `JSON.stringify` для перетворення об’єктів в JSON (він повертає JSON-рядок).
-- `JSON.parse` для перетворення JSON-рядка назад в об’єкт.
+- `JSON.stringify` для перетворення об'єктів в JSON (він повертає JSON-рядок).
+- `JSON.parse` для перетворення JSON-рядка назад в об'єкт.
 
 Наприклад, тут ми трансформуємо дані студента за домогою `JSON.stringify`:
 ```js run
@@ -52,7 +52,7 @@ alert(typeof json); // ми отримали рядок!
 
 alert(json);
 *!*
-/* JSON-кодований об’єкт:
+/* JSON-кодований об'єкт:
 {
   "name": "Іван",
   "age": 30,
@@ -64,20 +64,20 @@ alert(json);
 */!*
 ```
 
-Метод `JSON.stringify(student)` бере об’єкт і перетворює його в рядок.
+Метод `JSON.stringify(student)` бере об'єкт і перетворює його в рядок.
 
-Отриманий `json` рядок називається *JSON-кодованим* або *серіалізованим* об’єктом. Ми готові відправити його по мережі або покласти в звичайне сховище даних.
+Отриманий `json` рядок називається *JSON-кодованим* або *серіалізованим* об'єктом. Ми готові відправити його по мережі або покласти в звичайне сховище даних.
 
-Будь ласка, зверніть увагу, що JSON-кодований об’єкт має кілька важливих відмінностей від літерального об’єкта:
+Будь ласка, зверніть увагу, що JSON-кодований об'єкт має кілька важливих відмінностей від літерального об'єкта:
 
 - Рядки використовують подвійні лапки. Ніяких одинарних або зворотніх лапок у JSON. Тобто `'Іван'` стає `"Іван"`.
-- Назви властивостей об’єкта також обертаються в подвійні лапки. Це обов’язково. Тобто `age:30` стає `"age":30`.
+- Назви властивостей об'єкта також обертаються в подвійні лапки. Це обов'язково. Тобто `age:30` стає `"age":30`.
 
 `JSON.stringify` можна застосувати до примітивів.
 
 JSON підтримує наступні типи даних:
 
-- Об’єкти `{ ... }`
+- Об'єкти `{ ... }`
 - Масиви `[ ... ]`
 - Примітиви:
     - рядки,
@@ -99,7 +99,7 @@ alert( JSON.stringify(true) ); // true
 alert( JSON.stringify([1, 2, 3]) ); // [1,2,3]
 ```
 
-JSON -- незалежна від мови специфікація даних, тому `JSON.stringify` пропускає деякі специфічні для JavaScript властивості об’єктів.
+JSON -- незалежна від мови специфікація даних, тому `JSON.stringify` пропускає деякі специфічні для JavaScript властивості об'єктів.
 
 А саме:
 
@@ -116,12 +116,12 @@ let user = {
   something: undefined // ігнорується
 };
 
-alert( JSON.stringify(user) ); // {} (порожній об’єкт)
+alert( JSON.stringify(user) ); // {} (порожній об'єкт)
 ```
 
 Зазвичай це добре. Якщо це не те, чого ми хочемо, то скоро ми побачимо, як налаштувати процес.
 
-Чудово, що вкладені об’єкти підтримуються та перетворюються автоматично.
+Чудово, що вкладені об'єкти підтримуються та перетворюються автоматично.
 
 Наприклад:
 
@@ -212,7 +212,7 @@ alert( JSON.stringify(meetup, *!*['title', 'participants']*/!*) );
 // {"title":"Конференція","participants":[{},{}]}
 ```
 
-Тут ми, мабуть, занадто суворі. Список властивостей застосовується до всієї структури об’єкта. Тому об’єкти в `participants` будуть порожніми, бо `name` немає в списку.
+Тут ми, мабуть, занадто суворі. Список властивостей застосовується до всієї структури об'єкта. Тому об'єкти в `participants` будуть порожніми, бо `name` немає в списку.
 
 Включімо в список всі властивості, окрім `room.occupiedBy`, яка призводить до циклічного посилання:
 
@@ -279,20 +279,20 @@ occupiedBy:   [object Object]
 */
 ```
 
-Будь ласка, зверніть увагу, що функція `replacer` отримує кожну пару ключ/значення, включаючи вкладені об’єкти та елементи масиву. І вона застосовується рекурсивно. Значення `this` всередині `replacer` -- це об’єкт, який містить поточну властивість.
+Будь ласка, зверніть увагу, що функція `replacer` отримує кожну пару ключ/значення, включаючи вкладені об'єкти та елементи масиву. І вона застосовується рекурсивно. Значення `this` всередині `replacer` -- це об'єкт, який містить поточну властивість.
 
-Перший виклик особливий. Він зроблений з використанням спеціального "об’єкта обгортки": `{"": meetup}`. Іншими словами, перша пара `(key, value)` має порожній ключ, а значення є цільовим об’єктом загалом. Ось чому перший рядок в прикладі вище буде `":[object Object]"` .
+Перший виклик особливий. Він зроблений з використанням спеціального "об'єкта обгортки": `{"": meetup}`. Іншими словами, перша пара `(key, value)` має порожній ключ, а значення є цільовим об'єктом загалом. Ось чому перший рядок в прикладі вище буде `":[object Object]"` .
 
-Ідея полягає в тому, щоб забезпечити якомога більше можливостей для функції `replacer` -- вона має можливість аналізувати та замінити/пропустити навіть весь об’єкт, якщо це необхідно.
+Ідея полягає в тому, щоб забезпечити якомога більше можливостей для функції `replacer` -- вона має можливість аналізувати та замінити/пропустити навіть весь об'єкт, якщо це необхідно.
 
 
 ## Форматування: space
 
 Третій аргумент `JSON.stringify(value, replacer, space)` -- це кількість пробілів, що використовуються для гарного форматування.
 
-Раніше всі розтягнуті об’єкти не мали відступу та додаткових пробілів. Це добре, якщо ми хочемо надіслати об’єкт через мережу. Аргумент `space` використовується виключно для виводу в зручному для читання вигляді.
+Раніше всі розтягнуті об'єкти не мали відступу та додаткових пробілів. Це добре, якщо ми хочемо надіслати об'єкт через мережу. Аргумент `space` використовується виключно для виводу в зручному для читання вигляді.
 
-Тут `space = 2` указує JavaScript показати вкладені об’єкти на декількох рядках, з відступом у 2 пробіли всередині об’єкта:
+Тут `space = 2` указує JavaScript показати вкладені об'єкти на декількох рядках, з відступом у 2 пробіли всередині об'єкта:
 
 ```js run
 let user = {
@@ -334,7 +334,7 @@ alert(JSON.stringify(user, null, 2));
 
 ## Спеціальний "toJSON"
 
-Подібно до методу `toString` для перетворення в рядок, об’єкт також може мати метод `toJSON` для перетворення в JSON. Функція `JSON.stringify` автоматично викликає цей метод, якщо він є.
+Подібно до методу `toString` для перетворення в рядок, об'єкт також може мати метод `toJSON` для перетворення в JSON. Функція `JSON.stringify` автоматично викликає цей метод, якщо він є.
 
 Наприклад:
 
@@ -361,9 +361,9 @@ alert( JSON.stringify(meetup) );
 */
 ```
 
-Тут ми бачимо, що `date` `(1)` став рядком. Це тому, що всі об’єкти типу `Date` мають вбудований метод `toJSON`, який повертає такий рядок.
+Тут ми бачимо, що `date` `(1)` став рядком. Це тому, що всі об'єкти типу `Date` мають вбудований метод `toJSON`, який повертає такий рядок.
 
-Тепер додамо власну реалізацію методу `toJSON` в наш об’єкт `room` `(2)`:
+Тепер додамо власну реалізацію методу `toJSON` в наш об'єкт `room` `(2)`:
 
 ```js run
 let room = {
@@ -395,7 +395,7 @@ alert( JSON.stringify(meetup) );
 */
 ```
 
-Як ми можемо побачити, `toJSON` використовується як при прямому виклику `JSON.stringify(room)`, так і коли  `room` вкладений в іншому серіалізованому об’єкті.
+Як ми можемо побачити, `toJSON` використовується як при прямому виклику `JSON.stringify(room)`, так і коли  `room` вкладений в іншому серіалізованому об'єкті.
 
 
 ## JSON.parse
@@ -408,10 +408,10 @@ let value = JSON.parse(str, [reviver]);
 ```
 
 str
-: JSON-рядок для перетворення в об’єкт.
+: JSON-рядок для перетворення в об'єкт.
 
 reviver
-: Необов’язкова функція, яка буде викликана для кожного `(key, value)` та може перетворювати значення.
+: Необов'язкова функція, яка буде викликана для кожного `(key, value)` та може перетворювати значення.
 
 Наприклад:
 
@@ -434,7 +434,7 @@ let user = JSON.parse(userData);
 alert( user.friends[1] ); // 1
 ```
 
-JSON може бути настільки складним, наскільки це необхідно, об’єкти та масиви можуть включати інші об’єкти та масиви. Але вони повинні дотримуватися того ж формату JSON.
+JSON може бути настільки складним, наскільки це необхідно, об'єкти та масиви можуть включати інші об'єкти та масиви. Але вони повинні дотримуватися того ж формату JSON.
 
 Ось типові помилки в рукописному JSON (іноді ми повинні писати його для знаходження помилок):
 
@@ -456,7 +456,7 @@ let json = `{
 
 ## Використання reviver
 
-Уявіть, що ми отримали серіалізований об’єкт `meetup` з сервера.
+Уявіть, що ми отримали серіалізований об'єкт `meetup` з сервера.
 
 Ось такий:
 
@@ -465,7 +465,7 @@ let json = `{
 let str = '{"title":"Конференція","date":"2017-11-30T12:00:00.000Z"}';
 ```
 
-...І тепер нам потрібно *десеріалізувати* цей об’єкт, тобто знову перетворити його в об’єкт JavaScript.
+...І тепер нам потрібно *десеріалізувати* цей об'єкт, тобто знову перетворити його в об'єкт JavaScript.
 
 Зробімо це, викликавши `JSON.parse`:
 
@@ -481,9 +481,9 @@ alert( meetup.date.getDate() ); // Помилка!
 
 Ой! Помилка!
 
-Значення `meetup.date` -- це рядок, а не об’єкт `Date`. Як `JSON.parse` міг знати, що він повинен перетворити цей рядок на об’єкт `Date`?
+Значення `meetup.date` -- це рядок, а не об'єкт `Date`. Як `JSON.parse` міг знати, що він повинен перетворити цей рядок на об'єкт `Date`?
 
-Передаймо  до `JSON.parse` функції відновлення як другий аргумент, який повертає всі значення "як є", але `date` стане об’єктом `Date`:
+Передаймо  до `JSON.parse` функції відновлення як другий аргумент, який повертає всі значення "як є", але `date` стане об'єктом `Date`:
 
 ```js run
 let str = '{"title":"Конференція","date":"2017-11-30T12:00:00.000Z"}';
@@ -498,7 +498,7 @@ let meetup = JSON.parse(str, function(key, value) {
 alert( meetup.date.getDate() ); // зараз працює!
 ```
 
-До речі, це також працює для вкладених об’єктів:
+До речі, це також працює для вкладених об'єктів:
 
 ```js run
 let schedule = `{
@@ -523,7 +523,7 @@ alert( schedule.meetups[1].date.getDate() ); // працює!
 ## Підсумки
 
 - JSON -- це формат даних, який має власний незалежний стандарт та бібліотеки для більшості мов програмування.
-- JSON підтримує прості об’єкти, масиви, рядки, цифри, булеві значення та `null`.
+- JSON підтримує прості об'єкти, масиви, рядки, цифри, булеві значення та `null`.
 - JavaScript надає методи [JSON.stringify](mdn:js/JSON/stringify) для серіалізування в JSON і [JSON.parse](mdn:js/JSON/parse), щоб зчитати данні з JSON.
 - Обидва методи підтримують функції трансформації для інтелектуального читання/запису.
-- Якщо об’єкт має метод `toJSON`, то він викликається при виконанні `JSON.stringify`.
+- Якщо об'єкт має метод `toJSON`, то він викликається при виконанні `JSON.stringify`.
diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
index 2ee8470ba..09bc60ddf 100644
--- a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
@@ -37,4 +37,4 @@ P.S. Звичайно, формула є найшвидшим рішенням.
 
 Варіант з циклом є другим з точки зору швидкості. Як і у випадку рекурсії, в циклі ми сумуємо ті ж числа. Але рекурсія передбачає вкладені виклики та управління стеком. Це також займає ресурси, тому це повільніше.
 
-P.P.S. Деякі рушії підтримують оптимізацію "хвостового виклику" ("tail call"): якщо рекурсивний виклик є останнім в функції, то зовнішня функція не повинна відновлювати виконання, отже рушію не потрібно запам’ятовувати контекст виконання. Це зменшує використання пам’яті. Але якщо рушій JavaScript не підтримує оптимізацію хвостового виклику (більшість з них не підтримує), то виникне помилка: максимальний розмір стека перевищиться, оскільки зазвичай є обмеження на загальний розмір стека.
+P.P.S. Деякі рушії підтримують оптимізацію "хвостового виклику" ("tail call"): якщо рекурсивний виклик є останнім в функції, то зовнішня функція не повинна відновлювати виконання, отже рушію не потрібно запам'ятовувати контекст виконання. Це зменшує використання пам'яті. Але якщо рушій JavaScript не підтримує оптимізацію хвостового виклику (більшість з них не підтримує), то виникне помилка: максимальний розмір стека перевищиться, оскільки зазвичай є обмеження на загальний розмір стека.
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
index 420a40789..16e9b9e0f 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
@@ -33,11 +33,11 @@ fib(4) = fib(3) + fib(2)
 
 Ми можемо чітко простежити, що `fib(3)` вираховується двічі, а `fib(2)` -- тричі. Загальна кількість обчислень росте набагато швидше, ніж `n`, що робить його величезним навіть для `n=77`.
 
-Ми можемо оптимізувати це, запам’ятовуючи вже обчислені результати: якщо значення, скажімо, `fib(3)` обчислюється один раз, ми можемо просто повторно використовувати його в майбутніх обчисленнях.
+Ми можемо оптимізувати це, запам'ятовуючи вже обчислені результати: якщо значення, скажімо, `fib(3)` обчислюється один раз, ми можемо просто повторно використовувати його в майбутніх обчисленнях.
 
 Як інший варіант, ми можемо відмовитись від рекурсії та використати зовсім інший алгоритм на основі циклу.
 
-Замість переходу від `n` до нижчих значень ми можемо створити цикл, який починається з `1` і `2`, потім отримує `fib(3)` як їхню суму, а потім `fib(4)` як суму двох попередніх значень, потім `fib(5)` і йде вгору і вгору, поки не досягне потрібного значення. На кожному кроці нам потрібно лише запам’ятати два попередні значення.
+Замість переходу від `n` до нижчих значень ми можемо створити цикл, який починається з `1` і `2`, потім отримує `fib(3)` як їхню суму, а потім `fib(4)` як суму двох попередніх значень, потім `fib(5)` і йде вгору і вгору, поки не досягне потрібного значення. На кожному кроці нам потрібно лише запам'ятати два попередні значення.
 
 Ось кроки нового алгоритму в деталях.
 
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
index a723217f2..378b189a6 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
@@ -8,7 +8,7 @@ importance: 5
 
 Перші два числа: `1`, потім `2(1+1)`, потім `3(1+2)`, `5(2+3)` і так далі: `1, 1, 2, 3, 5, 8, 13, 21...`.
 
-Числа Фібоначчі пов’язані із [золотим перетином](https://uk.wikipedia.org/wiki/Золотий_перетин) і багатьма природними явищами навколо нас.
+Числа Фібоначчі пов'язані із [золотим перетином](https://uk.wikipedia.org/wiki/Золотий_перетин) і багатьма природними явищами навколо нас.
 
 Напишіть функцію `fib(n)`, яка повертає `n-th` число Фібоначчі.
 
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
index 088519190..551750467 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Вивести одинозв’язаний список
+# Вивести одинозв'язаний список
 
-Скажімо, у нас є одинозв’язаний список (як описано в розділі <info:recursion>):
+Скажімо, у нас є одинозв'язаний список (як описано в розділі <info:recursion>):
 
 ```js
 let list = {
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
index 039778180..37cf94abe 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
@@ -37,7 +37,7 @@ printReverseList(list);
 
 Немає можливості отримати останнє значення в нашому `list`. Ми також не можемо "повернутися назад".
 
-Отже, що ми можемо зробити, так це спочатку пройти елементи в прямому порядку і запам’ятати їх у масиві, а потім вивести те, що ми запам’ятали, в зворотному порядку:
+Отже, що ми можемо зробити, так це спочатку пройти елементи в прямому порядку і запам'ятати їх у масиві, а потім вивести те, що ми запам'ятали, в зворотному порядку:
 
 ```js run
 let list = {
@@ -71,4 +71,4 @@ function printReverseList(list) {
 printReverseList(list);
 ```
 
-Зверніть увагу, що рекурсивне рішення фактично робить точно так само: проходиться списком, запам’ятовує елементи в ланцюжку вкладених викликів (у контекстному стеку виконання), а потім виводить їх. 
+Зверніть увагу, що рекурсивне рішення фактично робить точно так само: проходиться списком, запам'ятовує елементи в ланцюжку вкладених викликів (у контекстному стеку виконання), а потім виводить їх. 
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
index 4309afe7f..db43b4e90 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Вивести одинозв’язаний список у зворотному порядку
+# Вивести одинозв'язаний список у зворотному порядку
 
-Виведіть одинозв’язаний список з попереднього завдання <info:task/output-single-linked-list> у зворотному порядку.
+Виведіть одинозв'язаний список з попереднього завдання <info:task/output-single-linked-list> у зворотному порядку.
 
 Зробіть два рішення: за допомогою циклу та з використанням рекурсії.
diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index d36559caf..3721e5e0c 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -96,7 +96,7 @@ function pow(x, n) {
 
 Максимальна кількість вкладених викликів (включаючи перший) називається *глибина рекурсії*. У нашому випадку вона буде точно дорівнювати `n`.
 
-Максимальна глибина рекурсії обмежена рушієм JavaScript. Ми можемо покластися, що вона може дорівнювати 10000, деякі рушії дозволяють отримати більшу глибину, але 100000, ймовірно, не підтримується більшістю з них. Є автоматичні оптимізації, які допомагають пом’якшити це ("оптимізація хвостових викликів"), але вони ще не підтримуються скрізь і працюють лише у простих випадках.
+Максимальна глибина рекурсії обмежена рушієм JavaScript. Ми можемо покластися, що вона може дорівнювати 10000, деякі рушії дозволяють отримати більшу глибину, але 100000, ймовірно, не підтримується більшістю з них. Є автоматичні оптимізації, які допомагають пом'якшити це ("оптимізація хвостових викликів"), але вони ще не підтримуються скрізь і працюють лише у простих випадках.
 
 Це обмежує застосування рекурсії, але вона все ще залишається дуже широко поширеною. Є багато завдань, де рекурсивний спосіб мислення дає простіший код, який легше підтримувати.
 
@@ -108,12 +108,12 @@ function pow(x, n) {
 
 [Контекст виконання](https:///tc39.github.io/ecma262/#sec-excution-contexts) -- це внутрішня структура даних, яка містить деталі про виконання функції: де зараз керуючий потік, поточні змінні, значення `this` (ми не використовуємо його тут) і кілька інших внутрішніх деталей.
 
-Один виклик функції має рівно один контекст виконання, пов’язаний з ним.
+Один виклик функції має рівно один контекст виконання, пов'язаний з ним.
 
 Коли функція робить вкладений виклик, відбувається наступне:
 
 - Поточна функція зупиняється.
-- Контекст виконання, пов’язаний з нею, запам’ятовується в спеціальній структурі даних, що називається *стек контекстів виконання*.
+- Контекст виконання, пов'язаний з нею, запам'ятовується в спеціальній структурі даних, що називається *стек контекстів виконання*.
 - Вкладений виклик виконується.
 - Після закінчення, старий контекст виконання витягується з стека, і зовнішня функція відновлюється з того місця, де вона зупинилася.
 
@@ -162,11 +162,11 @@ alert( pow(2, 3) );
 
 ### pow(2, 2)
 
-Щоб зробити вкладений виклик, JavaScript пам’ятає контекст поточного виконання в *стеці контексту виконання*.
+Щоб зробити вкладений виклик, JavaScript пам'ятає контекст поточного виконання в *стеці контексту виконання*.
 
 Тут ми викликаємо ту ж функцію `pow`, але це абсолютно не має значення. Цей процес однаковий для всіх функцій:
 
-1. Поточний контекст "запам’ятовується" на вершині стека.
+1. Поточний контекст "запам'ятовується" на вершині стека.
 2. Новий контекст створюється для підвиклику.
 3. Коли закінчиться підвиклик -- попередній контекст дістається зі стека, і його виконання продовжується.
 
@@ -183,7 +183,7 @@ alert( pow(2, 3) );
   </li>
 </ul>
 
-Новий поточний контекст виконання знаходиться на вершині (виділений жирним шрифтом), а попередні контексти знаходяться в пам’яті нижче.
+Новий поточний контекст виконання знаходиться на вершині (виділений жирним шрифтом), а попередні контексти знаходяться в пам'яті нижче.
 
 Коли ми закінчимо підвиклик, легко відновити попередній контекст, оскільки він зберігає як змінні, так і точне місце коду, де він зупинився.
 
@@ -234,7 +234,7 @@ function pow(x, n) {
 
 Немає більше вкладених викликів, тому функція закінчується, повертаючи `2`.
 
-Оскільки функція завершується, то контекст виконання більше не потрібний, тому він видаляється з пам’яті. Попередній контекст відновлюється з вершини стека:
+Оскільки функція завершується, то контекст виконання більше не потрібний, тому він видаляється з пам'яті. Попередній контекст відновлюється з вершини стека:
 
 
 <ul class="function-execution-context-list">
@@ -265,9 +265,9 @@ function pow(x, n) {
 
 Як ми бачимо з наведених вище ілюстрацій, глибина рекурсії дорівнює максимальній кількості контексту у стеці.
 
-Зверніть увагу на вимоги до пам’яті. Зберігання контекстів потребує пам’яті. У нашому випадку, підведення до степеня `n` фактично вимагає пам’яті для `n` контекстів, для всіх значень, що нижче `n`.
+Зверніть увагу на вимоги до пам'яті. Зберігання контекстів потребує пам'яті. У нашому випадку, підведення до степеня `n` фактично вимагає пам'яті для `n` контекстів, для всіх значень, що нижче `n`.
 
-Алгоритм на основі циклу економить більше пам’яті:
+Алгоритм на основі циклу економить більше пам'яті:
 
 ```js
 function pow(x, n) {
@@ -281,7 +281,7 @@ function pow(x, n) {
 }
 ```
 
-Ітеративний `pow` використовує єдиний контекст змінюючи `i` and `result` у процесі. Його вимоги до пам’яті невеликі, фіксовані та не залежать від `n`.
+Ітеративний `pow` використовує єдиний контекст змінюючи `i` and `result` у процесі. Його вимоги до пам'яті невеликі, фіксовані та не залежать від `n`.
 
 **Будь-яка рекурсія може бути переписана за допомогою циклу. Варіант з використанням циклу зазвичай може бути більш ефективним.**
 
@@ -293,7 +293,7 @@ function pow(x, n) {
 
 Ще одним чудовим застосування рекурсії є рекурсивний обхід.
 
-Уявіть, у нас є компанія. Структура персоналу може бути представлена як об’єкт:
+Уявіть, у нас є компанія. Структура персоналу може бути представлена як об'єкт:
 
 ```js
 let company = {
@@ -332,24 +332,24 @@ let company = {
 
 Тепер припустимо, що ми хочемо, щоб функція отримала суму всіх зарплат. Як ми можемо це зробити?
 
-Ітеративний підхід нелегкий, тому що структура не проста. Перша ідея може полягати в тому, щоб зробити `for` цикл через `company` з вкладеним підциклами через 1-ий рівень відділів. Але тоді нам потрібно більше вкладених циклів, щоб ітеруватися через персонал у 2-му рівні, такому як `sites`... А потім ще один підцикл всередині них для 3-го рівня, який міг би з’явитися в майбутньому? Якщо ми поставимо 3-4 вкладені цикли у коді, щоб пройти один об’єкт, це стає досить потворним.
+Ітеративний підхід нелегкий, тому що структура не проста. Перша ідея може полягати в тому, щоб зробити `for` цикл через `company` з вкладеним підциклами через 1-ий рівень відділів. Але тоді нам потрібно більше вкладених циклів, щоб ітеруватися через персонал у 2-му рівні, такому як `sites`... А потім ще один підцикл всередині них для 3-го рівня, який міг би з'явитися в майбутньому? Якщо ми поставимо 3-4 вкладені цикли у коді, щоб пройти один об'єкт, це стає досить потворним.
 
 Давайте спробуємо рекурсію.
 
 Як ми бачимо, коли наша функція отримує відділ для підрахунку суми зарплат, є два можливі випадки:
 
 1. Або це "простий" відділ з *масивом* людей -- тоді ми можемо підсумувати зарплату в простому циклі.
-2. Або це *об’єкт* з `n` підвідділами -- тоді ми можемо зробити `n` рекурсивних викликів, щоб отримати суму для кожного з підвідділів та поєднати результати.
+2. Або це *об'єкт* з `n` підвідділами -- тоді ми можемо зробити `n` рекурсивних викликів, щоб отримати суму для кожного з підвідділів та поєднати результати.
 
 1-й випадок є базою рекурсії, тривіальним випадком, коли ми отримуємо масив.
 
-2-й випадок, коли ми отримуємо об’єкт, -- це рекурсивний крок. Комплексне завдання розділяється на підзадачі для менших відділів. Вони в свою чергу можуть знову поділятися на підвідділи, але рано чи пізно поділ закінчиться і зведеться до випадку (1).
+2-й випадок, коли ми отримуємо об'єкт, -- це рекурсивний крок. Комплексне завдання розділяється на підзадачі для менших відділів. Вони в свою чергу можуть знову поділятися на підвідділи, але рано чи пізно поділ закінчиться і зведеться до випадку (1).
 
 Алгоритм, мабуть, навіть легше читати у вигляді коду:
 
 
 ```js run
-let company = { // той же об’єкт, стиснутий для компактності
+let company = { // той же об'єкт, стиснутий для компактності
   sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 1600 }],
   development: {
     sites: [{name: 'Peter', salary: 2000}, {name: 'Alex', salary: 1800 }],
@@ -381,12 +381,12 @@ alert(sumSalaries(company)); // 7700
 
 ![recursive salaries](recursive-salaries.svg)
 
-Ми можемо легко побачити принцип: для об’єкта `{...}` зроблені підвиклики, а масиви` `[...]` -- "листя" рекурсійного дерева, вони дають негайний результат.
+Ми можемо легко побачити принцип: для об'єкта `{...}` зроблені підвиклики, а масиви` `[...]` -- "листя" рекурсійного дерева, вони дають негайний результат.
 
 Зауважте, що код використовує розумні функції, які ми розглянули раніше:
 
 - Метод `arr.reduce` пояснено в розділі <info:array-methods>, щоб отримати суму масиву.
-- Цикл `for(val of Object.values(obj))` для ітерування значень об’єкта: `Object.values` повертає їх масив.
+- Цикл `for(val of Object.values(obj))` для ітерування значень об'єкта: `Object.values` повертає їх масив.
 
 
 ## Рекурсивні структури
@@ -397,7 +397,7 @@ alert(sumSalaries(company)); // 7700
 
 *Відділ* компанії це:
 - Або масив людей.
-- Або об’єкт з *відділами*.
+- Або об'єкт з *відділами*.
 
 Для веб-розробників набагато краще відомі приклади: HTML та XML-документи.
 
@@ -408,11 +408,11 @@ alert(sumSalaries(company)); // 7700
 
 Це ще одне рекурсивне визначення.
 
-Для кращого розуміння ми розглянемо ще одну рекурсивну структуру "Зв’язаний список", який може бути кращою альтернативою для масивів у деяких випадках.
+Для кращого розуміння ми розглянемо ще одну рекурсивну структуру "Зв'язаний список", який може бути кращою альтернативою для масивів у деяких випадках.
 
-### Зв’язаний список
+### Зв'язаний список
 
-Уявіть, що ми хочемо зберегти впорядкований список об’єктів.
+Уявіть, що ми хочемо зберегти впорядкований список об'єктів.
 
 Очевидним вибором буде масивом:
 
@@ -422,13 +422,13 @@ let arr = [obj1, obj2, obj3];
 
 ...Але є проблема з масивами. Операції "видалити елемент" та "вставити елемент" -- дорогі. Наприклад, операція `arr.unshift(obj)` повинна мати справу зі всіма елементами, щоб звільнити місце для нового `obj` і, якщо масив великий, це вимагає часу. Те ж саме з `arr.shift()`.
 
-Єдині структурні модифікації, які не потребують масової перенумерації об’єктів, є ті, які працюють з кінцем масиву: `arr.push/pop`. Таким чином, масив може бути досить повільним для великих черг, коли ми повинні працювати з його початком.
+Єдині структурні модифікації, які не потребують масової перенумерації об'єктів, є ті, які працюють з кінцем масиву: `arr.push/pop`. Таким чином, масив може бути досить повільним для великих черг, коли ми повинні працювати з його початком.
 
-Крім того, якщо нам дійсно потрібна швидка вставка/видалення, ми можемо вибрати іншу структуру даних, яка називається [зв’язаний список](https://uk.wikipedia.org/wiki/Зв'язаний_список).
+Крім того, якщо нам дійсно потрібна швидка вставка/видалення, ми можемо вибрати іншу структуру даних, яка називається [зв'язаний список](https://uk.wikipedia.org/wiki/Зв'язаний_список).
 
-*Елемент зв’язаного списку* рекурсивно визначається як об’єкт з:
+*Елемент зв'язаного списку* рекурсивно визначається як об'єкт з:
 - `value`.
-- `next` властивість, що посилається на наступний *елемент зв’язаного списку* або `null`, якщо це кінець.
+- `next` властивість, що посилається на наступний *елемент зв'язаного списку* або `null`, якщо це кінець.
 
 Наприклад:
 
@@ -462,9 +462,9 @@ list.next.next.next = { value: 4 };
 list.next.next.next.next = null;
 ```
 
-Тут ми можемо ще більш чітко бачити, що є декілька об’єктів, кожен з яких має `value` та `next`, що вказуює на сусіда. Змінна `list` -- це перший об’єкт у ланцюжку, тому слідуючи вказівникам `next` з неї ми можемо досягти будь-якого елемента.
+Тут ми можемо ще більш чітко бачити, що є декілька об'єктів, кожен з яких має `value` та `next`, що вказуює на сусіда. Змінна `list` -- це перший об'єкт у ланцюжку, тому слідуючи вказівникам `next` з неї ми можемо досягти будь-якого елемента.
 
-Список можна легко розділити на декілька частин, а пізніше з’єднати знову:
+Список можна легко розділити на декілька частин, а пізніше з'єднати знову:
 
 ```js
 let secondList = list.next.next;
@@ -505,7 +505,7 @@ list.next = list.next.next;
 
 ![linked list](linked-list-remove-1.svg)
 
-Ми зробили `list.next` стрибає через `1` на значення `2`. Значення `1` зараз виключається з ланцюга. Якщо воно не зберігається ніде, то воно буде автоматично видалено з пам’яті.
+Ми зробили `list.next` стрибає через `1` на значення `2`. Значення `1` зараз виключається з ланцюга. Якщо воно не зберігається ніде, то воно буде автоматично видалено з пам'яті.
 
 На відміну від масивів, немає массових перенумерацій, ми можемо легко переставляти елементи.
 
@@ -529,7 +529,7 @@ list.next = list.next.next;
 
 - [Рекурсивно визначена](https://uk.wikipedia.org/wiki/Рекурсивний_тип_даних) структура даних -- це структура даних, яка може бути визначена, з використанням самої себе.
 
-    Наприклад, зв’язаний список може бути визначений як структура даних, що складається з об’єкта, що посилається на список (або null).
+    Наприклад, зв'язаний список може бути визначений як структура даних, що складається з об'єкта, що посилається на список (або null).
 
     ```js
     list = { value, next -> list }
diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
index 965b7feea..925cfc74c 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
@@ -30,7 +30,7 @@ alert(sum(1, 2, 3, 4, 5));
 Наприклад, щоб зібрати всі аргументи в масив `args`:
 
 ```js run
-function sumAll(...args) { // args – це ім’я масиву
+function sumAll(...args) { // args – це ім'я масиву
   let sum = 0;
 
   for (let arg of args) sum += arg;
@@ -75,7 +75,7 @@ function f(arg1, ...rest, arg2) { // arg2 після ...rest ?!
 
 ## Змінна "arguments"
 
-Існує також спеціальний об’єкт, подібний масиву `arguments` який містить усі аргументи за їх індексом.
+Існує також спеціальний об'єкт, подібний масиву `arguments` який містить усі аргументи за їх індексом.
 
 Наприклад:
 
@@ -118,7 +118,7 @@ function f() {
 f(1); // 1
 ```
 
-Як ми пам’ятаємо, стрілочні функції не мають власних `this`. Тепер ми знаємо, що у них також немає особливого об'єкту `arguments`.
+Як ми пам'ятаємо, стрілочні функції не мають власних `this`. Тепер ми знаємо, що у них також немає особливого об'єкту `arguments`.
 ````
 
 
@@ -179,7 +179,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(1, ...arr1, 2, ...arr2, 25) ); // 25
 ```
 
-Також синтаксис розширення можна використовувати для об’єднання масивів:
+Також синтаксис розширення можна використовувати для об'єднання масивів:
 
 ```js run
 let arr = [3, 5, 1];
@@ -225,7 +225,7 @@ alert( Array.from(str) ); // H,e,l,l,o
 Отже, для завдання перетворити щось на масив `Array.from` буде більш універсальним.
 
 
-## Створити копію масива/об’єкта
+## Створити копію масива/об'єкта
 
 Пригадайте, коли ми говорили `Object.assign()` [в минулому розділі](info:object-copy#cloning-and-merging-object-assign)?
 
@@ -251,20 +251,20 @@ alert(arr); // 1, 2, 3, 4
 alert(arrCopy); // 1, 2, 3
 ```
 
-Зауважте, що те ж саме можна зробити, щоб зробити копію об’єкта:
+Зауважте, що те ж саме можна зробити, щоб зробити копію об'єкта:
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
 
 *!*
 let objCopy = { ...obj }; // розширить об'єкт у список параметрів
-                          // потім поверне результат у новий об’єкт
+                          // потім поверне результат у новий об'єкт
 */!*
 
-// чи однаковий вміст мають об’єкти?
+// чи однаковий вміст мають об'єкти?
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
 
-// чи однакові об’єкти?
+// чи однакові об'єкти?
 alert(obj === objCopy); // false (не однакові посилання)
 
 // зміна нашого початкового об'єкта не змінює копію:
@@ -273,7 +273,7 @@ alert(JSON.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
 alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
 ```
 
-Цей спосіб копіювання об’єкта набагато коротший, ніж `let objCopy = Object.assign({}, obj)` чи для масиву `let arrCopy = Object.assign([], arr)` тому ми вважаємо за краще використовувати його, коли це можливо.
+Цей спосіб копіювання об'єкта набагато коротший, ніж `let objCopy = Object.assign({}, obj)` чи для масиву `let arrCopy = Object.assign([], arr)` тому ми вважаємо за краще використовувати його, коли це можливо.
 
 
 ## Підсумки
@@ -292,4 +292,4 @@ alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
 
 Разом вони допомагають легко переміщатися між списком та масивом параметрів.
 
-Усі аргументи виклику функції також доступні в "олдскульному" ітерабельному об’єкті `arguments`.
+Усі аргументи виклику функції також доступні в "олдскульному" ітерабельному об'єкті `arguments`.
diff --git a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
index 1a14db5c7..b72ef3b31 100644
--- a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
+++ b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Об’єкт лічильника
+# Об'єкт лічильника
 
 Тут лічильник створюється за допомогою функції конструктора.
 
diff --git a/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md b/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
index eb9e533b2..628f8bda2 100644
--- a/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
+++ b/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Сортувати за полем
 
-У нас є масив об’єктів для сортування:
+У нас є масив об'єктів для сортування:
 
 ```js
 let users = [
@@ -17,7 +17,7 @@ let users = [
 Звичайний спосіб зробити це:
 
 ```js
-// За ім’ям (Енн, Іван, Петро)
+// За ім'ям (Енн, Іван, Петро)
 users.sort((a, b) => a.name > b.name ? 1 : -1);
 
 // За віком (Петро, Енн, Іван)
diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index 9db5e5cee..eacbc8a1e 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -120,9 +120,9 @@ function sayHiBye(firstName, lastName) {
 }
 ```
 
-Тут *вкладена* функція `getFullName()` створена для зручності. Вона має доступ до внутрішніх змінних функції і тому може повернути повне ім’я. Вкладені функції досить поширені в JavaScript.
+Тут *вкладена* функція `getFullName()` створена для зручності. Вона має доступ до внутрішніх змінних функції і тому може повернути повне ім'я. Вкладені функції досить поширені в JavaScript.
 
-Що ще цікавіше, вкладену функцію можна повернути: як властивість нового об’єкта, або як самостійний результат. Потім її можна використати десь в іншому місці. Незалежно від того, де її викликають, вона завжди буде мати доступ до внутрішніх змінних функцію, в якій її було створено.
+Що ще цікавіше, вкладену функцію можна повернути: як властивість нового об'єкта, або як самостійний результат. Потім її можна використати десь в іншому місці. Незалежно від того, де її викликають, вона завжди буде мати доступ до внутрішніх змінних функцію, в якій її було створено.
 
 Нижче, `makeCounter` створює функцію "counter", яка повертає наступний номер при кожному виклику:
 
@@ -160,20 +160,20 @@ alert( counter() ); // 2
 
 ### 1 етап. Змінні
 
-У JavaScript кожна запущена функція, блок коду `{...}`, і скрипт в цілому мають внутрішній (прихований) асоційований об’єкт, відомий як *Лексичне середовище (Lexical Environment)*.
+У JavaScript кожна запущена функція, блок коду `{...}`, і скрипт в цілому мають внутрішній (прихований) асоційований об'єкт, відомий як *Лексичне середовище (Lexical Environment)*.
 
-Об’єкт лексичного середовища складається з двох частин:
+Об'єкт лексичного середовища складається з двох частин:
 
-1. *Запис середовища (Environment Record)* -- об’єкт, який зберігає всі локальні змінні як властивості (та деяку іншу інформацію, наприклад значення `this`).
-2. Посилання на *зовнішнє лексичне середовище*, яке пов’язане із зовнішнім кодом.
+1. *Запис середовища (Environment Record)* -- об'єкт, який зберігає всі локальні змінні як властивості (та деяку іншу інформацію, наприклад значення `this`).
+2. Посилання на *зовнішнє лексичне середовище*, яке пов'язане із зовнішнім кодом.
 
-**"Змінна" це лише властивість спеціального внутрішнього об’єкта, `Запис середовища (Environment Record)`. "Отримати або змінити змінну" насправді означає "отримати або змінити властивість цього об’єкта".**
+**"Змінна" це лише властивість спеціального внутрішнього об'єкта, `Запис середовища (Environment Record)`. "Отримати або змінити змінну" насправді означає "отримати або змінити властивість цього об'єкта".**
 
 У цьому простому коді без функцій є лише одне лексичне середовище:
 
 ![lexical environment](lexical-environment-global.svg)
 
-Це так зване *глобальне* лексичне середовище, пов’язане з усім скриптом.
+Це так зване *глобальне* лексичне середовище, пов'язане з усім скриптом.
 
 На зображенні вище прямокутник означає запис середовища (сховище змінних), а стрілка означає зовнішнє посилання. Глобальне лексичне середовище не має зовнішнього посилання, тому стрілка вказує на `null`.
 
@@ -187,19 +187,19 @@ alert( counter() ); // 2
 
 1. Коли скрипт запускається, лексичне середовище попередньо заповнюється усіма оголошеними змінними.
     - Спочатку вони перебувають у стані "Неініціалізовано" (Uninitialized). Це особливий внутрішній стан, який означає, що рушій знає про змінну, але на неї не можна посилатися, поки вона не буде оголошена з `let`. Це майже те саме, ніби змінна не існує.
-2. Потім з’являється оголошення змінної `let phrase`. Поки що ми тільки оголосили змінну, тому її значення `undefined`. Але з цього моменту ми можемо використовувати її.
+2. Потім з'являється оголошення змінної `let phrase`. Поки що ми тільки оголосили змінну, тому її значення `undefined`. Але з цього моменту ми можемо використовувати її.
 3. `phrase` присвоюється значення.
 4. `phrase` змінює значення.
 
 Поки що все виглядає просто, правда?
 
-- Змінна -- це властивість спеціального внутрішнього об’єкта, пов’язана з блоком/функцієї/скриптом що зараз виконується.
-- Робота зі змінними -- це насправді робота з властивостями цього об’єкта.
+- Змінна -- це властивість спеціального внутрішнього об'єкта, пов'язана з блоком/функцієї/скриптом що зараз виконується.
+- Робота зі змінними -- це насправді робота з властивостями цього об'єкта.
 
 ```smart header="Лексичне середовище -- це об'єкт специфікації"
-"Лексичне середовище" -- це об’єкт специфікації: він існує лише "теоретично" в [специфікації мови](https://tc39.es/ecma262/#sec-lexical-environments) щоб показати, як все працює. Ми не можемо отримати цей об’єкт у нашому коді та керувати ним безпосередньо.
+"Лексичне середовище" -- це об'єкт специфікації: він існує лише "теоретично" в [специфікації мови](https://tc39.es/ecma262/#sec-lexical-environments) щоб показати, як все працює. Ми не можемо отримати цей об'єкт у нашому коді та керувати ним безпосередньо.
 
-Рушії JavaScript також можуть його оптимізувати, відкидати змінні, які не використовуються для економії пам’яті та виконувати інші внутрішні трюки, доки видима поведінка залишається такою, як описано у специфікації.
+Рушії JavaScript також можуть його оптимізувати, відкидати змінні, які не використовуються для економії пам'яті та виконувати інші внутрішні трюки, доки видима поведінка залишається такою, як описано у специфікації.
 ```
 
 ### 2 етап. Функції створені як Function Declarations
@@ -272,7 +272,7 @@ function makeCounter() {
 let counter = makeCounter();
 ```
 
-На початку кожного виклику `makeCounter()`, створюється новий об’єкт лексичного середовища для зберігання змінних конкретного виклику `makeCounter`.
+На початку кожного виклику `makeCounter()`, створюється новий об'єкт лексичного середовища для зберігання змінних конкретного виклику `makeCounter`.
 
 Отже, у нас є два вкладених лексичних середовища, як і у прикладі вище:
 
@@ -280,11 +280,11 @@ let counter = makeCounter();
 
 Різниця полягає в тому, що під час виконання `makeCounter()`, крихітна вкладена функція створюється, яка складається лише з одного рядка: `return count++`. Ми не запускаємо її, лише створюємо.
 
-Усі функції пам’ятають лексичне середовище, в якому вони були створені. Технічно тут немає ніякої магії: усі функції мають приховану властивість з назвою `[[Environment]]`, що зберігає посилання на лексичне середовище, де була створена функція:
+Усі функції пам'ятають лексичне середовище, в якому вони були створені. Технічно тут немає ніякої магії: усі функції мають приховану властивість з назвою `[[Environment]]`, що зберігає посилання на лексичне середовище, де була створена функція:
 
 ![](closure-makecounter-environment.svg)
 
-Тому, `counter.[[Environment]]` має посилання на лексичне середовище, яке має вигляд `{count: 0}`. Так функція запам’ятовує, де вона була створена, незалежно від того, де вона викликається. Посилання у `[[Environment]]` встановлюється раз і назавжди під час створення функції.
+Тому, `counter.[[Environment]]` має посилання на лексичне середовище, яке має вигляд `{count: 0}`. Так функція запам'ятовує, де вона була створена, незалежно від того, де вона викликається. Посилання у `[[Environment]]` встановлюється раз і назавжди під час створення функції.
 
 Пізніше коли `counter()` викликається, для виклику створюється нове лексичне середовище, а посилання на зовнішнє лексичне середовище для нього береться з `counter.[[Environment]]`:
 
@@ -303,16 +303,16 @@ let counter = makeCounter();
 ```smart header="Замикання"
 У програмуванні існує загальний термін "замикання", який розробники зазвичай мають знати.
 
-[Замикання](https://uk.wikipedia.org/wiki/Замикання_(програмування)) -- це функція, яка запам’ятовує свої зовнішні змінні та може отримати до них доступ. У деяких мовах це зовсім неможливо, або функція має бути написана особливим чином. Але, як пояснювалося вище, в JavaScript замикання для функції -- це природньо і не потребує жодних зусиль (є лише один виняток, який ми розглянемо у <info:new-function>).
+[Замикання](https://uk.wikipedia.org/wiki/Замикання_(програмування)) -- це функція, яка запам'ятовує свої зовнішні змінні та може отримати до них доступ. У деяких мовах це зовсім неможливо, або функція має бути написана особливим чином. Але, як пояснювалося вище, в JavaScript замикання для функції -- це природньо і не потребує жодних зусиль (є лише один виняток, який ми розглянемо у <info:new-function>).
 
-Тобто: функції автоматично запам’ятовують, де вони були створені, використовуючи приховану властивість `[[Environment]]`, а потім їхній код може отримати доступ до зовнішніх змінних.
+Тобто: функції автоматично запам'ятовують, де вони були створені, використовуючи приховану властивість `[[Environment]]`, а потім їхній код може отримати доступ до зовнішніх змінних.
 
 Коли під час співбесіди розробник отримує запитання "що таке замикання?", правильною відповіддю буде визначення замикання та пояснення, що всі функції в JavaScript є замиканнями, і, можливо, ще кілька слів про технічні деталі: властивість `[[Environment]]`, і як взагалі працюють лексичні середовища.
 ```
 
 ## Збирання сміття
 
-Зазвичай після завершення виклику функції з пам’яті видаляється її лексичне середовище з усіма змінними. Це тому, що немає посилань на нього. Як і будь-який об’єкт JavaScript, він зберігається в пам’яті лише тоді, коли він досяжний.
+Зазвичай після завершення виклику функції з пам'яті видаляється її лексичне середовище з усіма змінними. Це тому, що немає посилань на нього. Як і будь-який об'єкт JavaScript, він зберігається в пам'яті лише тоді, коли він досяжний.
 
 Однак, якщо є вкладена функція, яка все ще доступна після завершення виклику основної функції, то вона має властивість `[[Environment]]`, яка посилається на лексичне середовище, створене під час виклику.
 
@@ -333,7 +333,7 @@ let g = f(); // g.[[Environment]] зберігає посилання на ле
 // відповідного виклику f()
 ```
 
-Зверніть увагу, що якщо `f()` викликається багато разів, а отримані функції зберігаються, тоді всі відповідні об’єкти лексичного середовища також будуть збережені в пам’яті. У коді нижче збережені всі три:
+Зверніть увагу, що якщо `f()` викликається багато разів, а отримані функції зберігаються, тоді всі відповідні об'єкти лексичного середовища також будуть збережені в пам'яті. У коді нижче збережені всі три:
 
 ```js
 function f() {
@@ -342,14 +342,14 @@ function f() {
   return function() { alert(value); };
 }
 
-// три функції в масиві, кожна з яких пов’язана з лексичним середовищем
+// три функції в масиві, кожна з яких пов'язана з лексичним середовищем
 // відповідного виклику f()
 let arr = [f(), f(), f()];
 ```
 
-Об’єкт лексичного середовища "вмирає", коли стає недосяжним (як і будь-який інший об’єкт). Іншими словами, він існує лише тоді, коли на нього посилається принаймні одна вкладена функція.
+Об'єкт лексичного середовища "вмирає", коли стає недосяжним (як і будь-який інший об'єкт). Іншими словами, він існує лише тоді, коли на нього посилається принаймні одна вкладена функція.
 
-У наведеному нижче коді після видалення вкладеної функції, лексичне середовище, до якого вона мала доступ, також стирається з пам’яті:
+У наведеному нижче коді після видалення вкладеної функції, лексичне середовище, до якого вона мала доступ, також стирається з пам'яті:
 
 ```js
 function f() {
@@ -360,9 +360,9 @@ function f() {
   }
 }
 
-let g = f(); // поки функція g існує, значення залишається в пам’яті
+let g = f(); // поки функція g існує, значення залишається в пам'яті
 
-g = null; // ...і тепер пам’ять очищена
+g = null; // ...і тепер пам'ять очищена
 ```
 
 ### Оптимізації в реальному житті
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 97fdd1db6..d77b97507 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -143,7 +143,7 @@ function sayHi() {
 sayHi();
 ```
 
-...Або навіть як цей (пам’ятайте, блоки коду ігноруються):
+...Або навіть як цей (пам'ятайте, блоки коду ігноруються):
 
 ```js run
 function sayHi() {
@@ -282,6 +282,6 @@ function go() {
 1. Змінні `var` не мають блочної області видимості, їх видимість визначається поточною функцією або глобально, якщо оголошені поза функцією.
 2. Оголошення за допомогою `var` обробляються при запуску функції (або скрипта для глобальних змінних).
 
-Існує ще одна дуже незначна відмінність, пов’язана з глобальним об’єктом, яку ми розглянемо в наступному розділі.
+Існує ще одна дуже незначна відмінність, пов'язана з глобальним об'єктом, яку ми розглянемо в наступному розділі.
 
 Ці відмінності роблять `var` гірше, ніж `let` у більшості випадків. Блочна область видимості - гарна річ. Ось чому `let` давно був введений до стандарту і тепер є основним способом (разом з `const`) оголошування змінних.
diff --git a/1-js/06-advanced-functions/05-global-object/article.md b/1-js/06-advanced-functions/05-global-object/article.md
index 8d0502b6a..9d9cc1db2 100644
--- a/1-js/06-advanced-functions/05-global-object/article.md
+++ b/1-js/06-advanced-functions/05-global-object/article.md
@@ -1,15 +1,15 @@
 
-# Глобальний об’єкт
+# Глобальний об'єкт
 
-Глобальний об’єкт надає змінні та функції, доступні в будь-якому місці програми. За замовчуванням ті, які вбудовані в мову або середовище.
+Глобальний об'єкт надає змінні та функції, доступні в будь-якому місці програми. За замовчуванням ті, які вбудовані в мову або середовище.
 
 У браузері він має назву `window`, у Node.js -- `global`, для інших середовищ він може мати іншу назву.
 
-Нещодавно до мови було додано `globalThis` як стандартизовану назву глобального об’єкта, який має підтримуватися у всіх середовищах. Він підтримується у всіх основних браузерах.
+Нещодавно до мови було додано `globalThis` як стандартизовану назву глобального об'єкта, який має підтримуватися у всіх середовищах. Він підтримується у всіх основних браузерах.
 
 Ми будемо використовувати `window`, вважаючи, що наше середовище -- це браузер. Якщо ваш скрипт може працювати в інших середовищах, краще використовувати замість цього `globalThis`.
 
-До всіх властивостей глобального об’єкта можна отримати доступ напряму:
+До всіх властивостей глобального об'єкта можна отримати доступ напряму:
 
 ```js run
 alert("Привіт");
@@ -17,12 +17,12 @@ alert("Привіт");
 window.alert("Привіт");
 ```
 
-У браузері глобальні функції і змінні оголошені за допомогою `var` (не `let/const`!) стають властивостями глобального об’єкта:
+У браузері глобальні функції і змінні оголошені за допомогою `var` (не `let/const`!) стають властивостями глобального об'єкта:
 
 ```js run untrusted refresh
 var gVar = 5;
 
-alert(window.gVar); // 5 (змінна стала властивістю глобального об’єкта)
+alert(window.gVar); // 5 (змінна стала властивістю глобального об'єкта)
 ```
 
 Такий же ефект мають оголошення функцій (оператори з ключовим словом `function` у потоці основного коду, а не функціональні вирази).
@@ -34,7 +34,7 @@ alert(window.gVar); // 5 (змінна стала властивістю гло
 ```js run untrusted refresh
 let gLet = 5;
 
-alert(window.gLet); // undefined (змінна не стає властивістю глобального об’єкта)
+alert(window.gLet); // undefined (змінна не стає властивістю глобального об'єкта)
 ```
 
 Якщо значення настільки важливе, що ви хочете зробити його глобальним, то напишіть його безпосередньо як властивість:
@@ -50,7 +50,7 @@ window.currentUser = {
 // десь у коді
 alert(currentUser.name);  // John
 
-// або, якщо ми маємо локальну змінну з ім’ям "currentUser"
+// або, якщо ми маємо локальну змінну з ім'ям "currentUser"
 // отримаймо явно з window (безпечно!)
 alert(window.currentUser.name); // John
 ```
@@ -59,16 +59,16 @@ alert(window.currentUser.name); // John
 
 ## Використання поліфілів
 
-Ми використовуємо глобальний об’єкт для тестування підтримки сучасних мовних функцій браузером.
+Ми використовуємо глобальний об'єкт для тестування підтримки сучасних мовних функцій браузером.
 
-Наприклад, перевірте, чи існує вбудований об’єкт `Promise` (його немає у дуже старих браузерах):
+Наприклад, перевірте, чи існує вбудований об'єкт `Promise` (його немає у дуже старих браузерах):
 ```js run
 if (!window.Promise) {
   alert("Твій браузер застарів!");
 }
 ```
 
-Якщо його немає (побачимо повідомлення: "Твій браузер застарів!"), ми можемо створити «поліфіли», щоб додати підтримку цього об’єкту. Додати функції, які не підтримуються середовищем, але існують у сучасному стандарті.
+Якщо його немає (побачимо повідомлення: "Твій браузер застарів!"), ми можемо створити «поліфіли», щоб додати підтримку цього об'єкту. Додати функції, які не підтримуються середовищем, але існують у сучасному стандарті.
 
 ```js run
 if (!window.Promise) {
@@ -78,12 +78,12 @@ if (!window.Promise) {
 
 ## Підсумки
 
-- Глобальний об’єкт містить змінні, які мають бути доступними скрізь.
+- Глобальний об'єкт містить змінні, які мають бути доступними скрізь.
 
     Включаючи вбудовані у JavaScript, такі як `Array`, та значення, характерні для середовища, такі як `window.innerHeight` -- висота вікна у браузері.
-- Глобальний об’єкт має універсальну назву `globalThis`.
+- Глобальний об'єкт має універсальну назву `globalThis`.
 
     ... Але частіше згадуються специфічні назви середовища "старої школи", такі як `window` (браузер) та `global` (Node.js).
-- Ми повинні зберігати значення у глобальному об’єкті, лише якщо вони дійсно глобальні для нашого проєкту. І тримати їх кількість мінімальною.
-- В браузерах, якщо ми не використовуємо [модулі](info:modules), глобальні функції та змінні, оголошені за допомогою `var`, стають властивістю глобального об’єкта.
-- Для того, щоб код був простішим і в майбутньому його легше було підтримувати, слід звертатися до властивостей глобального об’єкта безпосередньо, через `window.x`.
+- Ми повинні зберігати значення у глобальному об'єкті, лише якщо вони дійсно глобальні для нашого проєкту. І тримати їх кількість мінімальною.
+- В браузерах, якщо ми не використовуємо [модулі](info:modules), глобальні функції та змінні, оголошені за допомогою `var`, стають властивістю глобального об'єкта.
+- Для того, щоб код був простішим і в майбутньому його легше було підтримувати, слід звертатися до властивостей глобального об'єкта безпосередньо, через `window.x`.
diff --git a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
index 4362256c5..8ad1a6466 100644
--- a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
+++ b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
@@ -1,7 +1,7 @@
 
 1. Загалом, для того щоб все працювало *хоч як-небудь*, результат `sum` повинен бути функцією.
-2. Ця функція повинна зберігати в пам’яті поточне значення між викликами.
-3. Згідно з завданням, функція повинна стати числом, коли використовується в `==`. Функції -- це об’єкти, тому перетворення відбувається як описано в розділі <info:object-toprimitive>, і ми можемо надати власний метод, який повертає номер.
+2. Ця функція повинна зберігати в пам'яті поточне значення між викликами.
+3. Згідно з завданням, функція повинна стати числом, коли використовується в `==`. Функції -- це об'єкти, тому перетворення відбувається як описано в розділі <info:object-toprimitive>, і ми можемо надати власний метод, який повертає номер.
 
 Тепер код:
 
diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index 5ff34c5f8..6025b81fb 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -1,18 +1,18 @@
 
-# Об’єкт функції, NFE
+# Об'єкт функції, NFE
 
 Як ми вже знаємо, функція в JavaScript -- це значення.
 
 Кожне значення в JavaScript має тип. Який тип функції?
 
-У JavaScript, функції є об’єктами.
+У JavaScript, функції є об'єктами.
 
-Ви можете уявити собі функції, як "об’єкти, що можна викликати, та які можуть виконувати якісь дії". Ми можемо не тільки викликати їх, але й ставитися до них як до об’єктів: додавати/видаляти властивості, передавати за посиланням тощо.
+Ви можете уявити собі функції, як "об'єкти, що можна викликати, та які можуть виконувати якісь дії". Ми можемо не тільки викликати їх, але й ставитися до них як до об'єктів: додавати/видаляти властивості, передавати за посиланням тощо.
 
 
 ## Властивість "name"
 
-Функціональні об’єкти містять деякі зручні властивості.
+Функціональні об'єкти містять деякі зручні властивості.
 
 Наприклад, назва функції доступна як властивість "name":
 
@@ -24,14 +24,14 @@ function sayHi() {
 alert(sayHi.name); // sayHi
 ```
 
-Що доволі смішно, логіка присвоєння "name" досить розумна. Вона працює так, що призначає правильне ім’я функції, навіть якщо функція була створена без імені, а потім була негайно призначена:
+Що доволі смішно, логіка присвоєння "name" досить розумна. Вона працює так, що призначає правильне ім'я функції, навіть якщо функція була створена без імені, а потім була негайно призначена:
 
 ```js run
 let sayHi = function() {
   alert("Привіт");
 };
 
-alert(sayHi.name); // sayHi (є ім’я!)
+alert(sayHi.name); // sayHi (є ім'я!)
 ```
 
 Це також працює, якщо призначення виконується за допомогою значення за замовчуванням:
@@ -44,9 +44,9 @@ function f(sayHi = function() {}) {
 f();
 ```
 
-У специфікації ця ознака називається "контекстне ім’я". Якщо функція не надає власне ім’я, то в присвоєнні воно з’являється з контексту.
+У специфікації ця ознака називається "контекстне ім'я". Якщо функція не надає власне ім'я, то в присвоєнні воно з'являється з контексту.
 
-Методи об’єктів також мають назви:
+Методи об'єктів також мають назви:
 
 ```js run
 let user = {
@@ -65,7 +65,7 @@ alert(user.sayHi.name); // sayHi
 alert(user.sayBye.name); // sayBye
 ```
 
-Проте тут немає ніякої магії. Є випадки, коли немає жодного способу з’ясувати правильну назву. У цьому випадку ім’я назви порожнє, як тут:
+Проте тут немає ніякої магії. Є випадки, коли немає жодного способу з'ясувати правильну назву. У цьому випадку ім'я назви порожнє, як тут:
 
 ```js run
 // функція створена всередині масиву
@@ -151,9 +151,9 @@ alert( `Викликана ${sayHi.counter} рази` ); // Викликана 2
 ```
 
 ```warn header="A property is not a variable"
-Властивість, присвоєна функції, як `sayhi.counter = 0` *не* визначає локальну змінну `counter` всередині цієї функції. Іншими словами, властивість `counter` та змінна `let counter` є двома незв’язаними речами.
+Властивість, присвоєна функції, як `sayhi.counter = 0` *не* визначає локальну змінну `counter` всередині цієї функції. Іншими словами, властивість `counter` та змінна `let counter` є двома незв'язаними речами.
 
-Ми можемо використовувати функцію як об’єкт, зберігати властивості у ньому, але це не впливатиме на її виконання. Змінні -- це не властивості функції і навпаки. Це два паралельні світи.
+Ми можемо використовувати функцію як об'єкт, зберігати властивості у ньому, але це не впливатиме на її виконання. Змінні -- це не властивості функції і навпаки. Це два паралельні світи.
 ```
 
 Властивості функцій можуть іноді замінити замикання. Наприклад, ми можемо переписати приклад функції лічильника з розділу <info:closure> використовуючи властивість функції:
@@ -209,7 +209,7 @@ alert( counter() ); // 10
 
 Named Function Expression, або NFE -- це термін для Function Expressions, у якого є назва.
 
-Наприклад, об’явімо звичайний Function Expression:
+Наприклад, об'явімо звичайний Function Expression:
 
 ```js
 let sayHi = function(who) {
@@ -303,7 +303,7 @@ welcome(); // Помилка, вкладений виклик sayHi більше
 
 Це відбувається тому, що функція приймає `sayHi` з його зовнішнього лексичного середовища. Там немає місцевого `sayHi`, тому використовується зовнішня змінна. І в момент виклику зовнішній `sayHi` є `null`.
 
-Необов’язкове ім’я, яке ми можемо ввести в Function Expression, призначене для розв’язання цих проблем.
+Необов'язкове ім'я, яке ми можемо ввести в Function Expression, призначене для розв'язання цих проблем.
 
 Використовуймо це, щоб виправити наш код:
 
@@ -326,7 +326,7 @@ welcome(); // Привіт, Гість (вкладений виклик вико
 
 Тепер це працює, тому що назва `"func"` -- локальне і знаходиться в середині функції. Воно не береться ззовні (і не доступно звідти). Специфікація гарантує, що воно завжди посилається на поточну функцію.
 
-Зовнішній код все ще має свою змінну `sayHi` або `welcome`. А `func` -- це "внутрішнє ім’я функції", яким функція може надійно викликати себе зсередини.
+Зовнішній код все ще має свою змінну `sayHi` або `welcome`. А `func` -- це "внутрішнє ім'я функції", яким функція може надійно викликати себе зсередини.
 
 ```smart header="Це не працює з Function Declaration"
 Функціональність з "внутрішньою назвою", що описана вище, доступна лише для Function Expression, а не для Function Declaration. Для Function Declaration немає синтаксису для додавання "внутрішньої" назви.
@@ -336,7 +336,7 @@ welcome(); // Привіт, Гість (вкладений виклик вико
 
 ## Підсумки
 
-Функції є об’єктами.
+Функції є об'єктами.
 
 Їх властивості:
 
diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md
index 1107c654e..5ef12be1f 100644
--- a/1-js/06-advanced-functions/07-new-function/article.md
+++ b/1-js/06-advanced-functions/07-new-function/article.md
@@ -46,7 +46,7 @@ func();
 
 ## Замикання
 
-Зазвичай функція пам’ятає, де вона народилася в спеціальній властивості `[[Environment]]`. Вона посилається на лексичне середовище, звідки функція була створена (ми розглянули це в розділі <info:closure>).
+Зазвичай функція пам'ятає, де вона народилася в спеціальній властивості `[[Environment]]`. Вона посилається на лексичне середовище, звідки функція була створена (ми розглянули це в розділі <info:closure>).
 
 Але коли функція створюється за допомогою `new Function`, її `[[Environment]]` встановлюється так, щоб вказати глобальне лексичне середовище, а не поточне.
 
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index 3a317d38c..7215c3e0d 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -98,7 +98,7 @@ clearTimeout(timerId);
 alert(timerId); // той самий ідентифікатор (не приймає значення null після скасування)
 ```
 
-Як ми бачимо з результату `alert`, в браузері ідентифікатор таймера -- це число. В інших середовищах це може бути щось інше. Наприклад, Node.js повертає об’єкт таймера з додатковими методами.
+Як ми бачимо з результату `alert`, в браузері ідентифікатор таймера -- це число. В інших середовищах це може бути щось інше. Наприклад, Node.js повертає об'єкт таймера з додатковими методами.
 
 Знову ж таки, немає загальної специфікації для цих методів, тому це нормально.
 
@@ -226,13 +226,13 @@ setTimeout(function run() {
 Коли функція передається у `setInterval/setTimeout`, до неї створюється внутрішнє посилання та зберігається у планувальнику. Це запобігає потраплянню функції до збиральника сміття, навіть якщо немає інших посилань на неї.
 
 ```js
-// функція залишається в пам’яті до тих пір, поки її не викликає планувальник
+// функція залишається в пам'яті до тих пір, поки її не викликає планувальник
 setTimeout(function() {...}, 100);
 ```
 
-Для `setInterval` функція залишається в пам’яті до виклику `clearInterval`.
+Для `setInterval` функція залишається в пам'яті до виклику `clearInterval`.
 
-Є й побічний ефект. Функція посилається на зовнішнє лексичне середовище, тому, поки вона живе, зовнішні змінні також живуть. Вони можуть зайняти набагато більше пам’яті, ніж сама функція. Тому, коли нам більше не потрібна запланована функція, краще її скасувати, навіть якщо вона дуже мала.
+Є й побічний ефект. Функція посилається на зовнішнє лексичне середовище, тому, поки вона живе, зовнішні змінні також живуть. Вони можуть зайняти набагато більше пам'яті, ніж сама функція. Тому, коли нам більше не потрібна запланована функція, краще її скасувати, навіть якщо вона дуже мала.
 ````
 
 ## setTimeout з нульовою затримкою
@@ -253,19 +253,19 @@ alert("Привіт");
 
 Перший рядок "додає виклик у календар після 0мс". Але планувальник почне "перевіряти календар" тільки після завершення поточного скрипту, тому `"Привіт"` є першим, а `"Світ"` - після нього. The first line "puts the call into calendar after 0ms".
 
-Існують також розширені, пов’язані з браузером, випадки використання тайм-аутів з нульовою затримкою, про які ми поговоримо в цьому розділі <info:event-loop>.
+Існують також розширені, пов'язані з браузером, випадки використання тайм-аутів з нульовою затримкою, про які ми поговоримо в цьому розділі <info:event-loop>.
 
 ````smart header="Нульова затримка насправді не дорівнює нулю (у браузері)"
-У браузері є обмеження щодо того, як часто можуть запускатися вкладені таймери. Згідно зі [HTML Living Standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers): "після п’яти вкладених таймерів інтервал змушений бути не менше 4 мілісекунд.".
+У браузері є обмеження щодо того, як часто можуть запускатися вкладені таймери. Згідно зі [HTML Living Standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers): "після п'яти вкладених таймерів інтервал змушений бути не менше 4 мілісекунд.".
 
-Давайте продемонструємо, що це означає, на прикладі нижче. `setTimeout` викликає перепланований себе з нульовою затримкою. Кожен виклик запам’ятовує реальний час з попереднього виклику в масиві `times`. Як виглядають реальні затримки? Подивимось:
+Давайте продемонструємо, що це означає, на прикладі нижче. `setTimeout` викликає перепланований себе з нульовою затримкою. Кожен виклик запам'ятовує реальний час з попереднього виклику в масиві `times`. Як виглядають реальні затримки? Подивимось:
 
 ```js run
 let start = Date.now();
 let times = [];
 
 setTimeout(function run() {
-  times.push(Date.now() - start); // запам’ятовуємо затримку з попереднього виклику
+  times.push(Date.now() - start); // запам'ятовуємо затримку з попереднього виклику
 
   if (start + 100 < Date.now()) alert(times); // показати затримки через 100 мс
   else setTimeout(run); // інакше перепланувати
@@ -275,7 +275,7 @@ setTimeout(function run() {
 // 1,1,1,1,9,15,20,24,30,35,40,45,50,55,59,64,70,75,80,85,90,95,100
 ```
 
-Перші таймери запускаються негайно (так, як написано в специфікації), а потім у гру вступає оов’язкова затримка між викликами 4+ мс і ми бачимо `9, 15, 20, 24 ...`.
+Перші таймери запускаються негайно (так, як написано в специфікації), а потім у гру вступає оов'язкова затримка між викликами 4+ мс і ми бачимо `9, 15, 20, 24 ...`.
 
 Подібне відбувається, якщо ми використовуємо `setInterval` замість `setTimeout`: `setInterval(f)` запускає `f` кілька разів з нульовою затримкою, а потім із затримкою 4+ мс.
 
@@ -290,7 +290,7 @@ setTimeout(function run() {
 - Щоб скасувати виконання, нам слід викликати `clearTimeout/clearInterval` зі значенням, яке повертає `setTimeout/setInterval`.
 - Вкладені виклики `setTimeout` є більш гнучкою альтернативою` setInterval`, що дозволяє нам більш точно встановити час *між* виконаннями.
 - Планування з нульовою затримкою за допомогою `setTimeout(func, 0)` (те саме, що `setTimeout(func)`) використовується для планування виклику "якомога швидше, але після завершення поточного скрипту".
-- Браузер обмежує мінімальну затримку для п’яти або більше вкладених викликів `setTimeout` або` setInterval` (після 5 -го виклику) до 4 мс. Це з історичних причин.
+- Браузер обмежує мінімальну затримку для п'яти або більше вкладених викликів `setTimeout` або` setInterval` (після 5 -го виклику) до 4 мс. Це з історичних причин.
 
 Зверніть увагу, що всі методи планування *не гарантують* точну затримку.
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
index fd3570bb2..fbc22f965 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
@@ -32,7 +32,7 @@ function throttle(func, ms) {
 Виклик `throttle(func, ms)` повертає `wrapper`.
 
 1. Під час першого виклику `wrapper` просто викликає `func` і встановлює стан відпочинку (`isThrottled = true`).
-2. У цьому стані всі виклики запам’ятовуються в `savedArgs/savedThis`. Зверніть увагу, що як контекст, так і аргументи однаково важливі, і повинні бути запам’ятованими. Нам потрібні вони їх одночасно, щоб відтворити виклик.
-3. Після того, як `ms` мілісекунди проходять, `setTimeout` спрацьовує. Стан відпочинку знімається (`isThrottled = false`) і, якщо ми мали проігноровані виклики, `wrapper` виконується з останніми запам’ятовуваними аргументами та контекстом.
+2. У цьому стані всі виклики запам'ятовуються в `savedArgs/savedThis`. Зверніть увагу, що як контекст, так і аргументи однаково важливі, і повинні бути запам'ятованими. Нам потрібні вони їх одночасно, щоб відтворити виклик.
+3. Після того, як `ms` мілісекунди проходять, `setTimeout` спрацьовує. Стан відпочинку знімається (`isThrottled = false`) і, якщо ми мали проігноровані виклики, `wrapper` виконується з останніми запам'ятовуваними аргументами та контекстом.
 
 3-й крок запускає не `func`, а `wrapper`, тому що ми не тільки повинні виконувати `func`, але й ще раз вводити стан відпочинку та налаштовувати тайм-аут, щоб скинути його.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index f133f3212..f1df83464 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -1,12 +1,12 @@
 # Декоратори та переадресація виклику, call/apply
 
-JavaScript дає виняткову гнучкість при роботі з функціями. Вони можуть бути передані в інші функції, використані як об’єкти, і тепер ми побачимо, як *перенаправляти* виклики між ними і *декорувати* їх.
+JavaScript дає виняткову гнучкість при роботі з функціями. Вони можуть бути передані в інші функції, використані як об'єкти, і тепер ми побачимо, як *перенаправляти* виклики між ними і *декорувати* їх.
 
 ## Прозоре кешування
 
 Скажімо, у нас є функція `slow(x)`, яка виконує ресурсоємкі операції, але її результати стабільні. Іншими словами, для того ж `x` вона завжди повертає той же результат.
 
-Якщо функція часто викликається, ми можемо кешувати (запам’ятати) її результати, щоб не витрачати час на перерахування.
+Якщо функція часто викликається, ми можемо кешувати (запам'ятати) її результати, щоб не витрачати час на перерахування.
 
 Але замість того, щоб додати цю функціональність в `slow()` ми створимо функцію-обгортку, що додає кешування. Як ми побачимо, існує багато переваг такого підходу.
 
@@ -29,7 +29,7 @@ function cachingDecorator(func) {
 
     let result = func(x);  // в іншому випадку викликати func
 
-    cache.set(x, result);  // і кешувати (запам’ятати) результат
+    cache.set(x, result);  // і кешувати (запам'ятати) результат
     return result;
   };
 }
@@ -63,7 +63,7 @@ alert( "Again: " + slow(2) ); // slow(2) result returned from cache
 
 ## Використання "func.call" для контексту
 
-Кешуючий декоратор, згаданий вище, не підходить для роботи з методами об’єкта.
+Кешуючий декоратор, згаданий вище, не підходить для роботи з методами об'єкта.
 
 Наприклад, у коді нижче `worker.slow()` перестане працювати після використання декоратора:
 
@@ -138,7 +138,7 @@ func.call(obj, 1, 2, 3)
 
 Обидва вони викликаюсь `func` з аргументами `1`, `2` і `3`. Єдина відмінність полягає в тому, що `func.call` також встановлює `this` рівним `obj`.
 
-Як приклад, у коді нижче ми викликаємо `sayHi` в контексті різних об’єктів: `sayHi.call(user)` викликає `sayHi`, передаючи `this=user`, а на наступних рядках встановлюється `this=admin`:
+Як приклад, у коді нижче ми викликаємо `sayHi` в контексті різних об'єктів: `sayHi.call(user)` викликає `sayHi`, передаючи `this=user`, а на наступних рядках встановлюється `this=admin`:
 
 ```js run
 function sayHi() {
@@ -148,7 +148,7 @@ function sayHi() {
 let user = { name: "Іван" };
 let admin = { name: "Адмін" };
 
-// використовуйте call, щоб передати різні об’єкти як "this"
+// використовуйте call, щоб передати різні об'єкти як "this"
 sayHi.call( user ); // Іван
 sayHi.call( admin ); // Адмін
 ```
@@ -206,7 +206,7 @@ alert( worker.slow(2) ); // працює, не викликаючи оригін
 Щоб все було зрозуміло, давайте подивимося більш глибоко, як `this` передається:
 
 1. Після декорування `worker.slow` стає функцією обгортки `function (x) { ... }`.
-2. Отже, коли `worker.slow(2)` виконується, обгортка отримує `2` в якості аргумента і `this=worker` (це об’єкт перед крапкою).
+2. Отже, коли `worker.slow(2)` виконується, обгортка отримує `2` в якості аргумента і `this=worker` (це об'єкт перед крапкою).
 3. Всередині обгортки, якщо результат ще не кешований, `func.call(this, x)` передає поточний `this` (`=worker`) та поточний аргумент (`=2`) до оригінального методу.
 
 ## Переходимо до декількох аргументів з «func.apply»
@@ -222,17 +222,17 @@ let worker = {
   }
 };
 
-// слід запам’ятати виклики з однаковими аргументами
+// слід запам'ятати виклики з однаковими аргументами
 worker.slow = cachingDecorator(worker.slow);
 ```
 
-Раніше, для одного аргументу `x`, ми могли просто `cache.set(x, result)`, щоб зберегти результат та `cache.get(x)`, щоб отримати його. Але тепер нам потрібно пам’ятати результат для *комбінації аргументів* `(min,max)`. Вбудований `Map` приймає лише одне значення як ключ.
+Раніше, для одного аргументу `x`, ми могли просто `cache.set(x, result)`, щоб зберегти результат та `cache.get(x)`, щоб отримати його. Але тепер нам потрібно пам'ятати результат для *комбінації аргументів* `(min,max)`. Вбудований `Map` приймає лише одне значення як ключ.
 
 Є багато можливих рішень:
 
 1. Впровадити нову (або скористайтеся сторонньою) map-подібну структуру даних, яка більш універсальна і дозволяє використовувати декілька ключів.
 2. Використати вкладені коллекції: `cache.set(min)` буде `Map`, що зберігає пару `(max, result)`. Таким чином, ми можемо отримати `result` як `cache.get(min).get(max)`.
-3. З’єднати два значення в одне. У нашому конкретному випадку ми можемо просто використовувати рядок `"min,max"` як ключ `Map`. Для гнучкості ми можемо забезпечити *функція хешування* для декоратора, що знає, як зробити одне значення з багатьох.
+3. З'єднати два значення в одне. У нашому конкретному випадку ми можемо просто використовувати рядок `"min,max"` як ключ `Map`. Для гнучкості ми можемо забезпечити *функція хешування* для декоратора, що знає, як зробити одне значення з багатьох.
 
 Для багатьох практичних застосунків, 3-й варіант досить хороший, тому ми будемо дотримуватися його.
 
@@ -312,7 +312,7 @@ func.apply(context, args);
 - Оператор розширення `...` дозволяє передати *ітерований* `args` як список до `call`.
 - `apply` приймає лише *псевдо-масив* `args`.
 
-... і для об’єктів, які є як ітерованими, так і псевдо-масивами, а так само як і справжніми масивами, ми можемо використовувати будь-який з цих методів, але `apply`, мабуть, буде швидше, тому що більшість рушіїв JavaScript внутрішньо оптимізують його краще.
+... і для об'єктів, які є як ітерованими, так і псевдо-масивами, а так само як і справжніми масивами, ми можемо використовувати будь-який з цих методів, але `apply`, мабуть, буде швидше, тому що більшість рушіїв JavaScript внутрішньо оптимізують його краще.
 
 Передача всіх аргументів разом з контекстом до іншої функції називається *переадресація виклику*.
 
@@ -346,9 +346,9 @@ function hash(args) {
 }
 ```
 
-...На жаль, це не буде працювати. Тому що ми викликаємо `hash(arguments)`, а об’єкт `arguments` є як ітерованим, так і псевдо-масивом, але не справжнім масивом.
+...На жаль, це не буде працювати. Тому що ми викликаємо `hash(arguments)`, а об'єкт `arguments` є як ітерованим, так і псевдо-масивом, але не справжнім масивом.
 
-Отже, виклик `join` на цьому об’єкті буде призводити до помилки, що ми бачимо нижче:
+Отже, виклик `join` на цьому об'єкті буде призводити до помилки, що ми бачимо нижче:
 
 ```js run
 function hash() {
@@ -360,7 +360,7 @@ function hash() {
 hash(1, 2);
 ```
 
-Тим не менш, є простий спосіб використи з’єднання масиву:
+Тим не менш, є простий спосіб використи з'єднання масиву:
 
 ```js run
 function hash() {
@@ -390,17 +390,17 @@ hash(1, 2);
 6. ...Робити це до тих пір, поки `this.length` елементів буде склеїно.
 7. Повернути `result`.
 
-Отже, технічно цей метод приймає `this` і з’єднує `this[0]`, `this[1]`  ... і т.д. разом. Він навмисно написаний таким чином, що дозволяє будь-який псевдо-масив `this` (не випадково, багато методів дотримуються цієї практики). Ось чому це також працює з `this=arguments`.
+Отже, технічно цей метод приймає `this` і з'єднує `this[0]`, `this[1]`  ... і т.д. разом. Він навмисно написаний таким чином, що дозволяє будь-який псевдо-масив `this` (не випадково, багато методів дотримуються цієї практики). Ось чому це також працює з `this=arguments`.
 
 ## Декоратори та функціональні властивості
 
-Як правило, можна безпечно замінити функцію або метод декоратором, за винятком однієї дрібниці. Якщо оригінальна функція мала властивості в собі, як наприклад `func.calledCount` або щось інше, то декорований об’єкт не буде надавати доступ до них. Тому що це обгортка. Тому потрібно бути обережним, якщо використовує її.
+Як правило, можна безпечно замінити функцію або метод декоратором, за винятком однієї дрібниці. Якщо оригінальна функція мала властивості в собі, як наприклад `func.calledCount` або щось інше, то декорований об'єкт не буде надавати доступ до них. Тому що це обгортка. Тому потрібно бути обережним, якщо використовує її.
 
 Наприклад, у прикладі вище, якщо `slow` функція мала будь-які властивості в собі, то `cachingDecorator(slow)` -- це обгортка без них.
 
 Деякі декоратори можуть забезпечити свої власні властивості.Наприклад, декоратор може підрахувати, скільки разів функція була викликана, і скільки часу це зайняло, і виставляти цю інформацію за допомогою властивостей обгортки.
 
-Існує спосіб створити декоратори, які зберігають доступ до властивостей функцій, але це вимагає використання спеціального об’єкту `Proxy`, щоб обернути функцію. Ми обговоримо це пізніше у статті <info:proxy#proxy-apply>.
+Існує спосіб створити декоратори, які зберігають доступ до властивостей функцій, але це вимагає використання спеціального об'єкту `Proxy`, щоб обернути функцію. Ми обговоримо це пізніше у статті <info:proxy#proxy-apply>.
 
 ## Підсумки
 
@@ -421,6 +421,6 @@ let wrapper = function() {
 };
 ```
 
-Ми також бачили приклад *запозичення методу*, коли ми беремо метод з об’єкта та `call` його в контексті іншого об’єкта.Досить поширено брати методи масиву та застосувати їх до `arguments`. Альтернативою є використання об’єкта, який є справжнім масивом, за допомогою rest оператору.
+Ми також бачили приклад *запозичення методу*, коли ми беремо метод з об'єкта та `call` його в контексті іншого об'єкта.Досить поширено брати методи масиву та застосувати їх до `arguments`. Альтернативою є використання об'єкта, який є справжнім масивом, за допомогою rest оператору.
 
 На практиці є багато декораторів для різних задач. Перевірте, наскільки добре ви засвоїли їх, вирішивши завдання цієї глави.
diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
index b98ba59c7..b349d5314 100644
--- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
@@ -13,6 +13,6 @@ let user = {
 user.g();
 ```
 
-Контекст прив’язаної функції жорстко-фіксований. Немає способу змінити це в подальшому.
+Контекст прив'язаної функції жорстко-фіксований. Немає способу змінити це в подальшому.
 
 Так чином в той час як ми запускаємо `user.g()`, функція `f` викликається з `this=null`.
diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
index 4de9f88e4..e394f738f 100644
--- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Прив’язана функція як метод
+# Прив'язана функція як метод
 
 Що виведе функція?
 
diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
index fc209c68f..dacb90668 100644
--- a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
@@ -10,6 +10,6 @@ f = f.bind( {name: "Іван"} ).bind( {name: "Христя"} );
 f(); // Іван
 ```
 
-Екзотичний об’єкт [прив’язаної функції](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) повертається від `f.bind(...)`, що запам’ятовує контекст (та аргументи, якщо передані) тільки під час створення. 
+Екзотичний об'єкт [прив'язаної функції](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) повертається від `f.bind(...)`, що запам'ятовує контекст (та аргументи, якщо передані) тільки під час створення. 
 
-Функція не може бути переприв’язана.
+Функція не може бути переприв'язана.
diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
index f4e12ae0e..9f119a741 100644
--- a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Друга прив’язка
+# Друга прив'язка
 
-Чи можемо ми змінити `this` за допомогою додаткового прив’язування?
+Чи можемо ми змінити `this` за допомогою додаткового прив'язування?
 
 Який результат буде виведено?
 
diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
index fe7ba11c3..5aadf02e9 100644
--- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
@@ -1,4 +1,4 @@
 Відповідь: `undefined`.
 
-Результатом `bind` є інший об’єкт. Він не містить властивість `test`.
+Результатом `bind` є інший об'єкт. Він не містить властивість `test`.
 
diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
index b5f92494a..a54902248 100644
--- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Властивість функції після прив’язки
+# Властивість функції після прив'язки
 
 Функції присвоєна властивість зі значенням. Чи зміниться вона після `bind`? Чому?
 
diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
index 1e93196ec..b0f33e437 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
@@ -1,9 +1,9 @@
 
-Помилка виникає тому що `askPassword` отримує функції `loginOk/loginFail` без об’єкту.
+Помилка виникає тому що `askPassword` отримує функції `loginOk/loginFail` без об'єкту.
 
 Коли вона викликає їх, їх контекст втрачено `this=undefined`.
 
-Спробуємо використати `bind`, щоб прив’язати контекст:
+Спробуємо використати `bind`, щоб прив'язати контекст:
 
 ```js run
 function askPassword(ok, fail) {
diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
index 97feda06e..0731c9ec3 100644
--- a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
+++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Задача трохи складніша ніж <info:task/question-use-bind>. 
 
-Об’єкт `user` був змінений. Тепер замість двох функцій `loginOk/loginFail`, він має одну функцію `user.login(true/false)`.
+Об'єкт `user` був змінений. Тепер замість двох функцій `loginOk/loginFail`, він має одну функцію `user.login(true/false)`.
 
 Що ми маємо передати `askPassword` в коді нижче, щоб вона викликала `user.login(true)` при `ok` та `user.login(false)` при `fail`?
 
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index 5292ef359..d02c6e89c 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -3,15 +3,15 @@ libs:
 
 ---
 
-# Прив’язка контексту до функції
+# Прив'язка контексту до функції
 
-Передаючи методи об’єкту в якості колбеків, наприклад в `setTimeout`, існує відома проблема: "втрата `this`".
+Передаючи методи об'єкту в якості колбеків, наприклад в `setTimeout`, існує відома проблема: "втрата `this`".
 
 В цьому розділі ми розглянемо способи як це можливо виправити.
 
 ## Втрата "this"
 
-Ми вже розглядали приклади втрати `this`. Якщо метод передавався окремо від об’єкта -- `this` втрачається.
+Ми вже розглядали приклади втрати `this`. Якщо метод передавався окремо від об'єкта -- `this` втрачається.
 
 В прикладі наведено як це відбувається з `setTimeout`:
 
@@ -30,16 +30,16 @@ setTimeout(user.sayHi, 1000); // Привіт, undefined!
 
 Як ми можемо спостерігати, модальне вікно браузера відображає не "Іван" як `this.firstName`, а `undefined`!
 
-Це тому що `setTimeout` отримав функцію `user.sayHi` окремо від об’єкта. Останній рядок бути переписаний наступним чином:
+Це тому що `setTimeout` отримав функцію `user.sayHi` окремо від об'єкта. Останній рядок бути переписаний наступним чином:
 
 ```js
 let f = user.sayHi;
-setTimeout(f, 1000); // втрата контексту об’єкта user
+setTimeout(f, 1000); // втрата контексту об'єкта user
 ```
 
-Метод `setTimeout` в браузері трохи особливий: він встановлює `this=window` під час виклику функції (для Node.js, `this` стане об’єкт таймеру, але це не дуже важливо у цьому випадку). Таким чином для `this.firstName` метод намагається отримати `window.firstName`, що не існує. В інших схожих випадках, зазвичай `this` просто стає `undefined`.
+Метод `setTimeout` в браузері трохи особливий: він встановлює `this=window` під час виклику функції (для Node.js, `this` стане об'єкт таймеру, але це не дуже важливо у цьому випадку). Таким чином для `this.firstName` метод намагається отримати `window.firstName`, що не існує. В інших схожих випадках, зазвичай `this` просто стає `undefined`.
 
-Задача досить типова -- ми хочемо передати метод об’єкту деінде (в цьому випадку -- в планувальник) де він буде викликаний. Як бути впевненими в тому, що він буде викликаний з правильним контекстом?
+Задача досить типова -- ми хочемо передати метод об'єкту деінде (в цьому випадку -- в планувальник) де він буде викликаний. Як бути впевненими в тому, що він буде викликаний з правильним контекстом?
 
 ## Рішення 1: обгортка
 
@@ -68,9 +68,9 @@ setTimeout(function() {
 setTimeout(() => user.sayHi(), 1000); // Привіт, Іван!
 ```
 
-Виглядає чудово, але з’являється легка вразливість в структурі нашого коду.
+Виглядає чудово, але з'являється легка вразливість в структурі нашого коду.
 
-Що якщо перед спрацюванням `setTimeout` (з однією секундою затримки!) `user` змінить значення? Тоді, неочікувано, він викличе неправильний об’єкт!
+Що якщо перед спрацюванням `setTimeout` (з однією секундою затримки!) `user` змінить значення? Тоді, неочікувано, він викличе неправильний об'єкт!
 
 
 ```js run
@@ -93,7 +93,7 @@ user = {
 
 Наступне рішення гарантує, що така ситуація не трапиться.
 
-## Рішення 2: прив’язка
+## Рішення 2: прив'язка
 
 Функції надають нам вбудований метод [bind](mdn:js/Function/bind), що дозволяє зберегти правильний `this`.
 
@@ -104,7 +104,7 @@ user = {
 let boundFunc = func.bind(context);
 ```
 
-Результатом `func.bind(context)` буде певний "екзотичний об’єкт", який може бути викликаний як функція та передає виклику `func` встановлений контекст `this=context`.
+Результатом `func.bind(context)` буде певний "екзотичний об'єкт", який може бути викликаний як функція та передає виклику `func` встановлений контекст `this=context`.
 
 Іншими словами, виклик `boundFunc` це як виклик `func` з виправленим `this`.
 
@@ -125,7 +125,7 @@ funcUser(); // Іван
 */!*
 ```
 
-Тут `func.bind(user)` як "прив’язаний варіант" функції `func`, з виправленим `this=user`.
+Тут `func.bind(user)` як "прив'язаний варіант" функції `func`, з виправленим `this=user`.
 
 Всі аргументи передаються початковій функції `func` "як є", наприклад:
 
@@ -138,7 +138,7 @@ function func(phrase) {
   alert(phrase + ', ' + this.firstName);
 }
 
-// прив’язка до user
+// прив'язка до user
 let funcUser = func.bind(user);
 
 *!*
@@ -146,7 +146,7 @@ funcUser("Привіт"); // Привіт, Іван (переданий аргу
 */!*
 ```
 
-Тепер спробуємо з методом об’єкту:
+Тепер спробуємо з методом об'єкту:
 
 
 ```js run
@@ -161,19 +161,19 @@ let user = {
 let sayHi = user.sayHi.bind(user); // (*)
 */!*
 
-// можемо викликати без об’єкту
+// можемо викликати без об'єкту
 sayHi(); // Привіт, Іван!
 
 setTimeout(sayHi, 1000); // Привіт, Іван!
 
 // навіть якщо значення user зміниться впродовж 1 секунди
-// sayHi використовує прив’язане значення, яке посилається на старий об’єкт user
+// sayHi використовує прив'язане значення, яке посилається на старий об'єкт user
 user = {
   sayHi() { alert("Інший user в setTimeout!"); }
 };
 ```
 
-В строчці `(*)` ми взяли метод `user.sayHi` та прив’язали його до `user`. `sayHi` є "прив’язаною" функцією, що може бути викликана окремо або передана до `setTimeout` -- не важливо, контекст буде правильний.
+В строчці `(*)` ми взяли метод `user.sayHi` та прив'язали його до `user`. `sayHi` є "прив'язаною" функцією, що може бути викликана окремо або передана до `setTimeout` -- не важливо, контекст буде правильний.
 
 В цьому прикладі ми можемо бачити що аргументи передані "як є", тільки `this` виправлено за допомогою `bind`:
 
@@ -192,7 +192,7 @@ say("Бувай"); // Бувай, Іван! ("Бувай" передане фу
 ```
 
 ````smart header="Зручний метод: `bindAll`"
-Якщо об’єкт містить багато методів та ми плануємо активно їх передавати, тоді ми можемо прив’язати їх всіх за допомогою циклу:
+Якщо об'єкт містить багато методів та ми плануємо активно їх передавати, тоді ми можемо прив'язати їх всіх за допомогою циклу:
 
 ```js
 for (let key in user) {
@@ -202,14 +202,14 @@ for (let key in user) {
 }
 ```
 
-JavaScript бібліотеки також пропонуються функції для зручної масової прив’язки, наприклад [_.bindAll(object, methodNames)](https://lodash.com/docs#bindAll) в бібліотеці lodash.
+JavaScript бібліотеки також пропонуються функції для зручної масової прив'язки, наприклад [_.bindAll(object, methodNames)](https://lodash.com/docs#bindAll) в бібліотеці lodash.
 ````
 
 ## Часткове застосування
 
-До цього моменту ми говорили тільки про прив’язку `this`. Зробимо крок далі.
+До цього моменту ми говорили тільки про прив'язку `this`. Зробимо крок далі.
 
-Ми можемо прив’язати не тільки `this`, а також аргументи. Це робиться рідко, проте може бути інколи дуже зручним.
+Ми можемо прив'язати не тільки `this`, а також аргументи. Це робиться рідко, проте може бути інколи дуже зручним.
 
 Повний синтаксис `bind`:
 
@@ -217,7 +217,7 @@ JavaScript бібліотеки також пропонуються функці
 let bound = func.bind(context, [arg1], [arg2], ...);
 ```
 
-Це дозволяє прив’язати context як `this` та початкові аргументи функції.
+Це дозволяє прив'язати context як `this` та початкові аргументи функції.
 
 Наприклад, ми маємо функцію множення `mul(a, b)`:
 
@@ -267,19 +267,19 @@ alert( triple(5) ); // = mul(3, 5) = 15
 
 Чому ми використовуємо часткове застосування?
 
-Перевагою цього є те, що ми можемо створити незалежну функцію з читабельним ім’ям (`double`, `triple`). Ми можемо використовувати її та не передавати перший аргумент кожен раз, оскільки це замість нас виконує `bind`.
+Перевагою цього є те, що ми можемо створити незалежну функцію з читабельним ім'ям (`double`, `triple`). Ми можемо використовувати її та не передавати перший аргумент кожен раз, оскільки це замість нас виконує `bind`.
 
 В інших випадках, часткове застосування є корисним, коли ми маємо дуже загальну функцію та хочемо менш універсальний її варіант для зручності.
 
-Наприклад, у нас є функція `send(from, to, text)`. Тоді, в середині об’єкту `user` ми можемо захотіти використати її частковий варіант: `sendTo(to, text)`, яка відправляє текст від поточного користувача.
+Наприклад, у нас є функція `send(from, to, text)`. Тоді, в середині об'єкту `user` ми можемо захотіти використати її частковий варіант: `sendTo(to, text)`, яка відправляє текст від поточного користувача.
 
 ## Використання часткового застосування без контексту
 
-Що якщо ми хочемо виправити деякі аргументи, але не контекст `this`? Наприклад, для методу об’єкта.
+Що якщо ми хочемо виправити деякі аргументи, але не контекст `this`? Наприклад, для методу об'єкта.
 
 Вбудований метод `bind` не дозволяє цього. Ми можемо просто опустити контекст та перейти до аргументів.
 
-На щастя, функція `partial` для прив’язування тільки аргументів може бути реалізована дуже просто.
+На щастя, функція `partial` для прив'язування тільки аргументів може бути реалізована дуже просто.
 
 Як тут:
 
@@ -319,9 +319,9 @@ user.sayNow("Привіт");
 
 ## Підсумки
 
-Метод `func.bind(context, ...args)` повертає a "прив’язаний варіант" функції `func` який виправляє контекст `this` та аргументи, якщо вони передані.
+Метод `func.bind(context, ...args)` повертає a "прив'язаний варіант" функції `func` який виправляє контекст `this` та аргументи, якщо вони передані.
 
-Зазвичай ми застосовуємо `bind`, щоб виправити `this` для методу об’єкта та передати його деінде. Наприклад, в `setTimeout`.
+Зазвичай ми застосовуємо `bind`, щоб виправити `this` для методу об'єкта та передати його деінде. Наприклад, в `setTimeout`.
 
 Коли ми виправляємо деякі аргументи існуючої функції, в результаті ми отримуємо (менш універсальну) функцію, яка називається *частково застосованою* або *частковою*.
 
diff --git a/1-js/06-advanced-functions/12-arrow-functions/article.md b/1-js/06-advanced-functions/12-arrow-functions/article.md
index 31e280d75..6e59d4973 100644
--- a/1-js/06-advanced-functions/12-arrow-functions/article.md
+++ b/1-js/06-advanced-functions/12-arrow-functions/article.md
@@ -18,9 +18,9 @@
 
 ## Стрілкові функції не мають "this"
 
-Як ми пам’ятаємо з розділу <info:object-methods>, стрілкові функції не мають `this`. Якщо відбувається звернення до `this`, його значення береться зовні.
+Як ми пам'ятаємо з розділу <info:object-methods>, стрілкові функції не мають `this`. Якщо відбувається звернення до `this`, його значення береться зовні.
 
-Наприклад, ми можемо використовувати це для ітерації всередині методу об’єкта:
+Наприклад, ми можемо використовувати це для ітерації всередині методу об'єкта:
 
 ```js run
 let group = {
@@ -72,8 +72,8 @@ group.showList();
 ```smart header="Стрілкові функції проти bind"
 Між стрілковою функцією `=>` та звичайною функцією, що викликається з `.bind(this)` є невеличка різниця:
 
-- `.bind(this)` створює "зв’язану версію" функції.
-- Стрілка `=>` не створює жодних прив’язок. Ця функція просто не має `this`. Пошук `this` здійснюється так само, як і звичайний пошук змінних: у зовнішньому лексичному середовищі.
+- `.bind(this)` створює "зв'язану версію" функції.
+- Стрілка `=>` не створює жодних прив'язок. Ця функція просто не має `this`. Пошук `this` здійснюється так само, як і звичайний пошук змінних: у зовнішньому лексичному середовищі.
 ```
 
 ## Стрілкові функції не мають "arguments"
diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md
index ae950979c..be89da968 100644
--- a/1-js/07-object-properties/01-property-descriptors/article.md
+++ b/1-js/07-object-properties/01-property-descriptors/article.md
@@ -1,15 +1,15 @@
 
 # Прапори та дескриптори властивостей
 
-Як відомо, об’єкти можуть зберігати властивості.
+Як відомо, об'єкти можуть зберігати властивості.
 
-Дотепер, для нас властивість була простою парою "ключ-значення". Однак насправді, властивість об’єкта є гнучкішою та потужнішою.
+Дотепер, для нас властивість була простою парою "ключ-значення". Однак насправді, властивість об'єкта є гнучкішою та потужнішою.
 
 У цьому розділі ми вивчимо додаткові параметри конфігурації, а в наступному ми побачимо, як можна непомітно перетворити їх у функції -- гетери та сетери.
 
 ## Прапори властивостей
 
-Властивості об’єкта, крім **`value`**, мають три спеціальні атрибути (так звані "прапори"):
+Властивості об'єкта, крім **`value`**, мають три спеціальні атрибути (так звані "прапори"):
 
 - **`writable`** -- якщо `true`, значення можна змінювати, інакше воно доступне лише для читання.
 - **`enumerable`** -- якщо `true`, то властивість враховується в циклах, в іншому випадку цикли його ігнорують.
@@ -27,12 +27,12 @@ let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);
 ```
 
 `obj`
-: Об’єкт, з якого буде отримана інформація.
+: Об'єкт, з якого буде отримана інформація.
 
 `propertyName`
 : Назва властивості.
 
-Повернене значення -- це так званий об’єкт "дескриптор властивості": він містить значення та всі прапори.
+Повернене значення -- це так званий об'єкт "дескриптор властивості": він містить значення та всі прапори.
 
 Наприклад:
 
@@ -63,10 +63,10 @@ Object.defineProperty(obj, propertyName, descriptor)
 ```
 
 `obj`, `propertyName`
-: Об’єкт і його властивість, щоб застосувати дескриптор.
+: Об'єкт і його властивість, щоб застосувати дескриптор.
 
 `descriptor`
-: Об’єкт дескриптора властивості, який буде застосовано.
+: Об'єкт дескриптора властивості, який буде застосовано.
 
 Якщо властивість існує, `defineProperty` оновлює її прапори. В іншому випадку метод створює властивість з даним значенням та прапорами; у цьому випадку, якщо прапор не вказано, передбачається, що його значення `false`.
 
@@ -120,7 +120,7 @@ user.name = "Петро"; // Помилка: неможливо присвоїт
 */!*
 ```
 
-Тепер ніхто не може змінити ім’я нашого користувача, якщо тільки не оновить відповідний прапор викликавши `defineProperty`, щоб перекрити наші дескриптори.
+Тепер ніхто не може змінити ім'я нашого користувача, якщо тільки не оновить відповідний прапор викликавши `defineProperty`, щоб перекрити наші дескриптори.
 
 ```smart header="Помилка виникає лише в суворому режимі"
 В несуворому режимі (без `use strict`), під час запису значення до недоступних для запису властивостей не виникне помилки. Однак така операція все одно не змінить значення. Дії, що порушують прапори, просто мовчки ігноруються в несуворому режимі.
@@ -148,7 +148,7 @@ user.name = "Петро"; // Помилка
 
 Тепер додаймо кастомний `toString` до `user`.
 
-Зазвичай, вбудований `toString` для об’єктів неперелічуваний, тобто він не з’являється в `for..in`. Але якщо ми додамо свій власний `toString`, то за замовчуванням він з’являється в `for..in`:
+Зазвичай, вбудований `toString` для об'єктів неперелічуваний, тобто він не з'являється в `for..in`. Але якщо ми додамо свій власний `toString`, то за замовчуванням він з'являється в `for..in`:
 
 ```js run
 let user = {
@@ -162,7 +162,7 @@ let user = {
 for (let key in user) alert(key); // name, toString
 ```
 
-Якщо нам це не подобається, то ми можемо встановити `enumerable:false`. Тоді `toString` не з’явиться в `for..in` так само, як вбудований метод.
+Якщо нам це не подобається, то ми можемо встановити `enumerable:false`. Тоді `toString` не з'явиться в `for..in` так само, як вбудований метод.
 
 ```js run
 let user = {
@@ -192,7 +192,7 @@ alert(Object.keys(user)); // name
 
 ## Неналаштовувані властивості
 
-Прапор неналаштовуваної властивості (`configurable:false`) іноді встановлений для вбудованих об’єктів та властивостей.
+Прапор неналаштовуваної властивості (`configurable:false`) іноді встановлений для вбудованих об'єктів та властивостей.
 
 Неналаштовувана властивість не може бути видалена, її атрибути не можуть бути змінені.
 
@@ -302,13 +302,13 @@ Object.defineProperties(user, {
 
 Щоб отримати всі дескриптори одночасно, ми можемо використовувати метод [Object.getOwnPropertyDescriptors(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors).
 
-Разом з `Object.defineProperties` цей метод може бути використаний як "прапорний" спосіб клонування об’єкта:
+Разом з `Object.defineProperties` цей метод може бути використаний як "прапорний" спосіб клонування об'єкта:
 
 ```js
 let clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
 ```
 
-Зазвичай, коли ми клонуємо об’єкт, ми використовуємо присвоєння для копіювання властивостей:
+Зазвичай, коли ми клонуємо об'єкт, ми використовуємо присвоєння для копіювання властивостей:
 
 ```js
 for (let key in user) {
@@ -320,14 +320,14 @@ for (let key in user) {
 
 Інша відмінність полягає в тому, що `for..in` ігнорує символьні властивості, але `Object.getOwnPropertyDescriptors` повертає *всі* дескриптори властивостей, включаючи символьні або незліченні.
 
-## Глобальне запечатування об’єкта
+## Глобальне запечатування об'єкта
 
 Дескриптори властивостей працюють на рівні окремих властивостей.
 
-Існують також способи, які обмежують доступ до *всього* об’єкта:
+Існують також способи, які обмежують доступ до *всього* об'єкта:
 
 [Object.preventExtensions(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions)
-: Забороняє додавання нових властивостей до об’єкта.
+: Забороняє додавання нових властивостей до об'єкта.
 
 [Object.seal(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal)
 : Забороняє додавання/видалення властивостей. Встановлює `configurable: false` для всіх властивостей, що існують.
diff --git a/1-js/07-object-properties/02-property-accessors/article.md b/1-js/07-object-properties/02-property-accessors/article.md
index 5ab33150d..8ebd36329 100644
--- a/1-js/07-object-properties/02-property-accessors/article.md
+++ b/1-js/07-object-properties/02-property-accessors/article.md
@@ -1,7 +1,7 @@
 
 # Гетери і сетери властивостей
 
-Є два види властивостей об’єкта.
+Є два види властивостей об'єкта.
 
 Перший вид *властивості даних (data properties)*. Ми вже знаємо, як працювати з ними. Всі властивості, які ми використовували дотепер, були властивостями даних.
 
@@ -9,7 +9,7 @@
 
 ## Гетери та сетери
 
-Властивості аксесорів представлені методами "гетер" та "сетер". У об’єкті вони буквально позначаються як `get` і `set`:
+Властивості аксесорів представлені методами "гетер" та "сетер". У об'єкті вони буквально позначаються як `get` і `set`:
 
 ```js
 let obj = {
@@ -25,7 +25,7 @@ let obj = {
 
 Гетер працює, коли `obj.propName` зчитується, сетер -- коли він призначається.
 
-Наприклад, у нас є об’єкт `user` з `name` і `surname`:
+Наприклад, у нас є об'єкт `user` з `name` і `surname`:
 
 ```js
 let user = {
@@ -87,7 +87,7 @@ let user = {
 */!*
 };
 
-// виконується встановлення повного ім’я із заданим значенням.
+// виконується встановлення повного ім'я із заданим значенням.
 user.fullName = "Аліса Бондар";
 
 alert(user.name); // Аліса
@@ -165,7 +165,7 @@ let user = {
 
   set name(value) {
     if (value.length < 4) {
-      alert("Ім’я занадто коротке, потрібно щонайменше 4 символи");
+      alert("Ім'я занадто коротке, потрібно щонайменше 4 символи");
       return;
     }
     this._name = value;
@@ -175,19 +175,19 @@ let user = {
 user.name = "Петро";
 alert(user.name); // Петро
 
-user.name = ""; // Ім’я занадто коротке...
+user.name = ""; // Ім'я занадто коротке...
 ```
 
-Отже, ім’я зберігається у властивості `_name`, а доступ виконується за допомогою гетера та сетера.
+Отже, ім'я зберігається у властивості `_name`, а доступ виконується за допомогою гетера та сетера.
 
-Технічно зовнішній код може мати доступ до ім’я безпосередньо за допомогою `user._name`. Але існує широко відома домовленість, що властивості, що починаються з підкреслення `"_"`, є внутрішніми і не повинні використовуватися ззовні об’єкта.
+Технічно зовнішній код може мати доступ до ім'я безпосередньо за допомогою `user._name`. Але існує широко відома домовленість, що властивості, що починаються з підкреслення `"_"`, є внутрішніми і не повинні використовуватися ззовні об'єкта.
 
 
 ## Використання для сумісності
 
 Одним з чудових прикладів використання аксесорів полягає у тому, що вони дозволяють контролювати "звичайну" властивість даних в будь-який момент, замінюючи її гетером і сетером і налаштовуючи її поведінку.
 
-Уявіть, що ми почали реалізувати об’єкти користувача за допомогою властивостей даних `name` та `age`:
+Уявіть, що ми почали реалізувати об'єкти користувача за допомогою властивостей даних `name` та `age`:
 
 ```js
 function User(name, age) {
@@ -217,7 +217,7 @@ let john = new User("Іван", new Date(1992, 6, 1));
 
 Залишмо його.
 
-Додавання гетера для `age` розв’язує проблему:
+Додавання гетера для `age` розв'язує проблему:
 
 ```js run no-beautify
 function User(name, birthday) {
diff --git a/1-js/07-object-properties/index.md b/1-js/07-object-properties/index.md
index b08e36406..e37cbc336 100644
--- a/1-js/07-object-properties/index.md
+++ b/1-js/07-object-properties/index.md
@@ -1,3 +1,3 @@
-# Властивості об’єкта, їх конфігурація
+# Властивості об'єкта, їх конфігурація
 
-В цьому розділі ми повернемося до об’єктів та вивчимо їхні властивості більше детально.
+В цьому розділі ми повернемося до об'єктів та вивчимо їхні властивості більше детально.
diff --git a/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md b/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md
index 65f70bb72..1f5c3140f 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md
@@ -4,7 +4,7 @@
 
 # Робота з прототипами
 
-Ось код, у якому створюють пару об’єктів і потім в ході виконання їх модифікують.
+Ось код, у якому створюють пару об'єктів і потім в ході виконання їх модифікують.
 
 Які значення будуть показані в результаті виконання коду?
 
diff --git a/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md
index afce3743a..c827d292f 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md
@@ -27,6 +27,6 @@
     alert( table.money ); // undefined
     ```
 
-2. Для сучасних рушіїв немає різниці, звідки ми беремо властивість -- з самого об’єкта, чи його прототипу. Рушії запам’ятовують де розташована властивість і при повторному запиті одразу її використовують.
+2. Для сучасних рушіїв немає різниці, звідки ми беремо властивість -- з самого об'єкта, чи його прототипу. Рушії запам'ятовують де розташована властивість і при повторному запиті одразу її використовують.
 
-    Наприклад, для `pockets.glasses` вони запам’ятають, що властивість `glasses` знаходиться в об’єкті `head`, і наступного разу шукатимуть її там. Вони також достатньо розумні для поновлення внутрішньої пам’яті, якщо вона була змінена, а тому подібна оптимізація є достатньо безпечною.
+    Наприклад, для `pockets.glasses` вони запам'ятають, що властивість `glasses` знаходиться в об'єкті `head`, і наступного разу шукатимуть її там. Вони також достатньо розумні для поновлення внутрішньої пам'яті, якщо вона була змінена, а тому подібна оптимізація є достатньо безпечною.
diff --git a/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md
index 97b77a7c4..89e6d860b 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Задача має дві частини.
 
-Ми маємо ось такі об’єкти:
+Ми маємо ось такі об'єкти:
 
 ```js
 let head = {
diff --git a/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md
index c6c5ab6b8..f4e3b39f8 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md
@@ -1,6 +1,6 @@
 **Відповідь: `rabbit`.**
 
-Це тому, що ключове слово `this` вказує на об’єкт перед крапкою, отже `rabbit.eat()` буде записано в `rabbit`.
+Це тому, що ключове слово `this` вказує на об'єкт перед крапкою, отже `rabbit.eat()` буде записано в `rabbit`.
 
 Пошук метода та його виконання - це дві різні речі.
 
diff --git a/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md
index ae73f5204..498a8533e 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md
@@ -4,9 +4,9 @@ importance: 5
 
 # Де буде записано?
 
-Ми маємо об’єкт `rabbit`, котрий успадковує властивості від об’єкта `animal`.
+Ми маємо об'єкт `rabbit`, котрий успадковує властивості від об'єкта `animal`.
 
-Якщо ми викличемо `rabbit.eat()`, у який з об’єктів буде записана властивість `full`: в `animal` чи `rabbit`?
+Якщо ми викличемо `rabbit.eat()`, у який з об'єктів буде записана властивість `full`: в `animal` чи `rabbit`?
 
 ```js
 let animal = {
diff --git a/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
index 4dcd6da2c..81cc70668 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md
@@ -1,6 +1,6 @@
 Подивімося уважно, що відбувається у виклику `speedy.eat("apple")`.
 
-1. Метод `speedy.eat` знаходиться в прототипі (`=hamster`), і виконується з `this=speedy` (об’єкт перед крапкою).
+1. Метод `speedy.eat` знаходиться в прототипі (`=hamster`), і виконується з `this=speedy` (об'єкт перед крапкою).
 
 2. Потім `this.stomach.push()` повинен знайти властивість `stomach` і викликати `push` на ньому. Він шукає `stomach` в `this` (`=speedy`), але нічого не знаходить.
 
@@ -8,9 +8,9 @@
 
 4. Потім він викликає `push` на ньому, додаючи їжу до *шлунку прототипу*.
 
-Таким чином, усі хом’ячки мають спільний шлунок!
+Таким чином, усі хом'ячки мають спільний шлунок!
 
-Для обох методів `lazy.stomach.push(...)` і `speedy.stomach.push()`, властивість `stomach` знаходисться в прототипі (бо в самих об’єктах такої властивості немає), яка отримує нові дані.
+Для обох методів `lazy.stomach.push(...)` і `speedy.stomach.push()`, властивість `stomach` знаходисться в прототипі (бо в самих об'єктах такої властивості немає), яка отримує нові дані.
 
 Зауважте, що така річ не відбувається у випадку простого визначення `this.stomach=`:
 
@@ -34,17 +34,17 @@ let lazy = {
   __proto__: hamster
 };
 
-// Хом’ячок 'Speedy' знайшов їжу
+// Хом'ячок 'Speedy' знайшов їжу
 speedy.eat("apple");
 alert( speedy.stomach ); // apple
 
-// Шлунок хом’ячка 'Lazy' пустий
+// Шлунок хом'ячка 'Lazy' пустий
 alert( lazy.stomach ); // <нічого>
 ```
 
-Тепер все працює добре, тому що `this.stomach=` не виконує пошук властивості `stomach`. Значення записується прямо в `this` об’єкта.
+Тепер все працює добре, тому що `this.stomach=` не виконує пошук властивості `stomach`. Значення записується прямо в `this` об'єкта.
 
-Також, ми можемо узагалі уникнути проблеми визначивши шлунок для кожного хом’ячка окремо, ось так:
+Також, ми можемо узагалі уникнути проблеми визначивши шлунок для кожного хом'ячка окремо, ось так:
 
 ```js run
 let hamster = {
@@ -69,12 +69,12 @@ let lazy = {
 */!*
 };
 
-// Хом’ячок `Speedy` знайшов їжу
+// Хом'ячок `Speedy` знайшов їжу
 speedy.eat("яблуко");
 alert( speedy.stomach ); // яблуко
 
-//  Шлунок хом’ячка `Lazy` пустий
+//  Шлунок хом'ячка `Lazy` пустий
 alert( lazy.stomach ); // <нічого>
 ```
 
-Отже, спільним рішенням може бути те, що всі властивості, які описують стан конкретного об’єкта (подібно як `stomach`), повинні бути записані (визначені) в цьому ж самому об’єкті. Це уникне подібної проблеми.
+Отже, спільним рішенням може бути те, що всі властивості, які описують стан конкретного об'єкта (подібно як `stomach`), повинні бути записані (визначені) в цьому ж самому об'єкті. Це уникне подібної проблеми.
diff --git a/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md
index 1d29a7a74..19ff5c4c6 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Чому обидва хом’ячка наситились?
+# Чому обидва хом'ячка наситились?
 
-Ми маємо два хом’ячка (об’єкти): `speedy` та `lazy`, які успадковують властивості від загального об’єкта `hamster`. 
+Ми маємо два хом'ячка (об'єкти): `speedy` та `lazy`, які успадковують властивості від загального об'єкта `hamster`. 
 
 Коли ми годуємо одного з них, інший також стає ситим. Але чому? Як ми можемо це виправити?
 
@@ -25,7 +25,7 @@ let lazy = {
   __proto__: hamster
 };
 
-// Цей хом’ячок знайшов їду
+// Цей хом'ячок знайшов їду
 speedy.eat("apple");
 alert( speedy.stomach ); // apple
 
diff --git a/1-js/08-prototypes/01-prototype-inheritance/article.md b/1-js/08-prototypes/01-prototype-inheritance/article.md
index 7b93df1fe..7129b1a0d 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/article.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/article.md
@@ -2,17 +2,17 @@
 
 У програмуванні ми часто хочемо щось взяти і доповнити чи розширити.
 
-Наприклад, ми маємо об’єкт `user` з його властивостями та методами, і хочемо створити `admin` та `guest` як дещо змінені варіанти об’єкта `user`. Тобто ми хочемо повторно використовувати те, що ми маємо в `user`, але також додати ще власні методи і властивості. Інакше кажучи, просто хочемо збудувати новий об’єкт поверх того, що існує.
+Наприклад, ми маємо об'єкт `user` з його властивостями та методами, і хочемо створити `admin` та `guest` як дещо змінені варіанти об'єкта `user`. Тобто ми хочемо повторно використовувати те, що ми маємо в `user`, але також додати ще власні методи і властивості. Інакше кажучи, просто хочемо збудувати новий об'єкт поверх того, що існує.
 
 *Успадкування через прототипи* -- це те, що нам допоможе в цьому.
 
 ## Спеціальна властивість [[Prototype]]
 
-В JavaScript, об’єкти мають спеціальну приховану властивість `[[Prototype]]` (як зазначено в специфікаціях мови), яка може приймати значення: або `null`, або мати посилання на інший об’єкт. Цей об’єкт називається "прототип":
+В JavaScript, об'єкти мають спеціальну приховану властивість `[[Prototype]]` (як зазначено в специфікаціях мови), яка може приймати значення: або `null`, або мати посилання на інший об'єкт. Цей об'єкт називається "прототип":
 
 ![prototype](object-prototype-empty.svg)
 
-Коли ми зчитуємо якусь властивість об’єкта `object`, але її не має, JavaScript автоматично бере її з прототипу. В програмуванні це називається "успадкування через прототипи". В скорому часі, ми вивчимо багато прикладів такого успадкування, як і створення більш цікавих прикладів, які побудовані на їх основі.
+Коли ми зчитуємо якусь властивість об'єкта `object`, але її не має, JavaScript автоматично бере її з прототипу. В програмуванні це називається "успадкування через прототипи". В скорому часі, ми вивчимо багато прикладів такого успадкування, як і створення більш цікавих прикладів, які побудовані на їх основі.
 
 Така властивість `[[Prototype]]` є внутрішньою та прихованою, але є багато шляхів щоб її визначити.
 
@@ -31,7 +31,7 @@ rabbit.__proto__ = animal; // тут встановлюємо rabbit.[[Prototype
 */!*
 ```
 
-І тепер, якщо ми зчитуємо властивість з об’єкта `rabbit`, а її немає, то JavaScript автоматично візьме її з `animal`.
+І тепер, якщо ми зчитуємо властивість з об'єкта `rabbit`, а її немає, то JavaScript автоматично візьме її з `animal`.
 
 Ось ще приклад:
 
@@ -47,20 +47,20 @@ let rabbit = {
 rabbit.__proto__ = animal; // (*)
 */!*
 
-// тепер ми можемо знайти обидві властивості в об’єкті rabbit:
+// тепер ми можемо знайти обидві властивості в об'єкті rabbit:
 *!*
 alert( rabbit.eats ); // true (**)
 */!*
 alert( rabbit.jumps ); // true
 ```
 
-В позначеному `(*)` рядку, об’єкт `animal` визначається як прототип для об’єкта `rabbit`.
+В позначеному `(*)` рядку, об'єкт `animal` визначається як прототип для об'єкта `rabbit`.
 
-І коли `alert` намагається прочитати властивість `rabbit.eats` (рядок позначено `(**)`), а її там немає, то JavaScript йде за посиланням `[[Prototype]]` та знаходить її в об’єкті `animal` (дивіться знизу вверх):
+І коли `alert` намагається прочитати властивість `rabbit.eats` (рядок позначено `(**)`), а її там немає, то JavaScript йде за посиланням `[[Prototype]]` та знаходить її в об'єкті `animal` (дивіться знизу вверх):
 
 ![](proto-animal-rabbit.svg)
 
-Ми можемо сказати, що "`animal` є прототипом для `rabbit`", або "об’єкт `rabbit` успадковує властивості об’єкта `animal`".
+Ми можемо сказати, що "`animal` є прототипом для `rabbit`", або "об'єкт `rabbit` успадковує властивості об'єкта `animal`".
 
 Якщо `animal` має багато корисних властивостей та методів, вони стають автоматично доступними для `rabbit`. Такі властивості називаються "успадкованими".
 
@@ -117,19 +117,19 @@ let longEar = {
 
 // Метод walk беремо з ланцюжка прототипів
 longEar.walk(); // отримуємо "Тварина йде"
-alert(longEar.jumps); // true (береться з об’єкта rabbit)
+alert(longEar.jumps); // true (береться з об'єкта rabbit)
 ```
 
 ![](proto-animal-rabbit-chain.svg)
 
-І тепер, якщо ми хочемо взяти метод з об’єкта `longEar`, а його там немає, JavaScript буде шукати його в `rabbit`, далі в `animal`.
+І тепер, якщо ми хочемо взяти метод з об'єкта `longEar`, а його там немає, JavaScript буде шукати його в `rabbit`, далі в `animal`.
 
 Існує два обмеження:
 
 1. Посилання через прототипи не може бути замкнено в кільце. JavaScript видасть помилку, якщо ми визначемо `__proto__` в ланцюжку прототипів і замкнем його в кільце.
 2. Значення `__proto__` може бути, або посиланням на об'єкт, або `null`. Інші типи значень - ігноруються.
 
-Хоч це і очевидно, але все ж таки: може бути тільки одна властивість `[[Prototype]]`. Об’єкт не може успадковувати властивості та методи від двох прототипів одночасно.
+Хоч це і очевидно, але все ж таки: може бути тільки одна властивість `[[Prototype]]`. Об'єкт не може успадковувати властивості та методи від двох прототипів одночасно.
 
 ```smart header="`__proto__` є старим і давнім getter/setter для `[[Prototype]]`"
 Вважається поширеною помилкою, особливо для початківців, неможливість чітко визначити різницю між двома поняттями `__proto__` та `[[Prototype]]`.
@@ -147,15 +147,15 @@ alert(longEar.jumps); // true (береться з об’єкта rabbit)
 
 Прототипи можна використовувати тільки для зчитування властивостей.
 
-А такі операції як запис/видалення, працюють напряму тільки на самому об’єкті.
+А такі операції як запис/видалення, працюють напряму тільки на самому об'єкті.
 
-У прикладі нижче, ми визначаємо власний метод `walk` для об’єкта `rabbit`:
+У прикладі нижче, ми визначаємо власний метод `walk` для об'єкта `rabbit`:
 
 ```js run
 let animal = {
   eats: true,
   walk() {
-    /* цей метод не буде використаний об’єктом rabbit */
+    /* цей метод не буде використаний об'єктом rabbit */
   }
 };
 
@@ -172,7 +172,7 @@ rabbit.walk = function() {
 rabbit.walk(); // тут отримаємо 'Кролик! Скік-скік!'
 ```
 
-Як тільки ми задаємо метод таким чином `rabbit.walk()`, виклик одразу знайде його на самому об’єкті та виконає без використання такого самого методу, який визначений в прототипі:
+Як тільки ми задаємо метод таким чином `rabbit.walk()`, виклик одразу знайде його на самому об'єкті та виконає без використання такого самого методу, який визначений в прототипі:
 
 ![](proto-animal-rabbit-walk-2.svg)
 
@@ -204,30 +204,30 @@ alert(admin.fullName); // John Smith (*)
 // відпрацьовує setter
 admin.fullName = "Alice Cooper"; // (**)
 
-alert(admin.fullName); // Alice Cooper, стан об’єкта admin було змінено
-alert(user.fullName); // John Smith, стан об’єкта user захищено
+alert(admin.fullName); // Alice Cooper, стан об'єкта admin було змінено
+alert(user.fullName); // John Smith, стан об'єкта user захищено
 ```
 
 Тут на рядку позначеному `(*)`, властивість `admin.fullName` викликається через getter, визначений в прототипі `user`. А на рядку позначеному `(**)` властивість задається через setter, який також визначений в прототипі.
 
 ## Значення ключового слова "this"
 
-Цікаве питання може виникнути в прикладі вище: яке значення ключового слова `this` всередині `set fullName(value)`? Де визначаютья властивості `this.name` та `this.surname`: в об’єкті `user` чи `admin`?
+Цікаве питання може виникнути в прикладі вище: яке значення ключового слова `this` всередині `set fullName(value)`? Де визначаютья властивості `this.name` та `this.surname`: в об'єкті `user` чи `admin`?
 
 Відповідь проста: на `this` не впливає прототип узагалі.
 
-**Незалежно від того, де метод визначений: в об’єкті чи його прототипі, ключове слово `this` завжди вказує на об’єкт перед крапкою.**
+**Незалежно від того, де метод визначений: в об'єкті чи його прототипі, ключове слово `this` завжди вказує на об'єкт перед крапкою.**
 
-Таким чином, виклик в методі `set` виразу `admin.fullName=` буде брати як `this` значення властивостей з об’єкту `admin` а не `user`.
+Таким чином, виклик в методі `set` виразу `admin.fullName=` буде брати як `this` значення властивостей з об'єкту `admin` а не `user`.
 
-В дійсності це є дуже важлива річ бо наприклад, ми можемо мати дуже великий об’єкт з багатьма методами, і також маємо об’єкти, які успадковують властивості або методи від того великого об’єкту. Коли успадковані методи викликаються на стороні об’єктів, що їх успадкували, вони можуть змінювати тільки свої стани а не стан того великого об’єкту.
+В дійсності це є дуже важлива річ бо наприклад, ми можемо мати дуже великий об'єкт з багатьма методами, і також маємо об'єкти, які успадковують властивості або методи від того великого об'єкту. Коли успадковані методи викликаються на стороні об'єктів, що їх успадкували, вони можуть змінювати тільки свої стани а не стан того великого об'єкту.
 
-У цьому прикладі, об’єкт `animal` представляє "набір методів", а об’єкт `rabbit` може використовувати якісь з цих методів.
+У цьому прикладі, об'єкт `animal` представляє "набір методів", а об'єкт `rabbit` може використовувати якісь з цих методів.
 
-Виклик `rabbit.sleep()` встановлює `this.isSleeping` в об’єкті `rabbit`:
+Виклик `rabbit.sleep()` встановлює `this.isSleeping` в об'єкті `rabbit`:
 
 ```js run
-// об’єкт animal має набір методів has
+// об'єкт animal має набір методів has
 let animal = {
   walk() {
     if (!this.isSleeping) {
@@ -255,9 +255,9 @@ alert(animal.isSleeping); // undefined (немає такої властивос
 
 ![](proto-animal-rabbit-walk-3.svg)
 
-Якщо ми маємо інші об’єкти: `bird`, `snake` тощо, які успадковані від об’єкта `animal`, вони також будуть мати доступ до методів `animal`. Кожний раз, при виклику будь-якого методу, ключове слово `this` буде вказувати на той об’єкт, на стороні якого був викликаний цей метод, а не на об’єкт `animal`. Отже, коли ми записуємо будь-які дані в `this`, вони зберігаються в об’єктах на які і вказує `this`.
+Якщо ми маємо інші об'єкти: `bird`, `snake` тощо, які успадковані від об'єкта `animal`, вони також будуть мати доступ до методів `animal`. Кожний раз, при виклику будь-якого методу, ключове слово `this` буде вказувати на той об'єкт, на стороні якого був викликаний цей метод, а не на об'єкт `animal`. Отже, коли ми записуємо будь-які дані в `this`, вони зберігаються в об'єктах на які і вказує `this`.
 
-Як результат, методи можуть успадковуватись (передаватись), але стани об’єктів - не можуть.
+Як результат, методи можуть успадковуватись (передаватись), але стани об'єктів - не можуть.
 
 ## Цикл for..in
 
@@ -311,7 +311,7 @@ for(let prop in rabbit) {
 }
 ```
 
-У цьому прикладі ми маємо наступний ланцюжок: `rabbit` успадковує властивості від об’єкта `animal`, який, у свою чергу, успадковує властивості від глобального `Object.prototype` (тому що `animal` типово є літералом об’єкта `{...}`) і на самому верху маємо `null`:
+У цьому прикладі ми маємо наступний ланцюжок: `rabbit` успадковує властивості від об'єкта `animal`, який, у свою чергу, успадковує властивості від глобального `Object.prototype` (тому що `animal` типово є літералом об'єкта `{...}`) і на самому верху маємо `null`:
 
 ![](rabbit-animal-object.svg)
 
@@ -319,20 +319,20 @@ for(let prop in rabbit) {
 
 ...але чому метод `hasOwnProperty` не визначає в циклі `for..in` властивості `eats` та `jumps`, якщо сам цикл `for..in` ітерує або проходить по цим успадкованим властивостям?
 
-Відповідь проста: вони позначені (кажемо стоять під прапорцем) як такі, що не рахуються (not enumerable) так само як і інші властивості в глобальному об’єкті `Object.prototype`. Прапорець у цьому випадку стоїть як `enumerable:false`, а цикл `for..in` тільки зчитує властивості, які визначені як такі, що перераховуються. Ось чому і решта властивостей глобального об’єкту `Object.prototype` не зчитуються також.
+Відповідь проста: вони позначені (кажемо стоять під прапорцем) як такі, що не рахуються (not enumerable) так само як і інші властивості в глобальному об'єкті `Object.prototype`. Прапорець у цьому випадку стоїть як `enumerable:false`, а цикл `for..in` тільки зчитує властивості, які визначені як такі, що перераховуються. Ось чому і решта властивостей глобального об'єкту `Object.prototype` не зчитуються також.
 
 ```smart header="Майже всі інші методи по отриманню пар ключ/значення ігнорують успадковані властивості"
 Отримання пар ключ/значення в інших методах, таких як: `Object.keys`, `Object.values` тощо, ігнорують успадковані властивості.
 
-Методи працюють тільки на самому об’єкті. Властивості від прототипів *не* беруться до уваги.
+Методи працюють тільки на самому об'єкті. Властивості від прототипів *не* беруться до уваги.
 ```
 
 ## Підсумки
 
-- В JavaScript, усі об’єкти мають приховану властивість `[[Prototype]]`, яка може бути іншим об’єктом або `null`.
+- В JavaScript, усі об'єкти мають приховану властивість `[[Prototype]]`, яка може бути іншим об'єктом або `null`.
 - Ми можемо використати `obj.__proto__` для доступу до цієї властивості (це історичний getter/setter; є й інші методи, які розглянемо згодом).
-- Об’єкт, на який посилається властивість `[[Prototype]]` називається "прототип".
-- Якщо ми хочемо прочитати властивості об’єкта `obj` чи викликаємо метод, який не існує, тоді JavaScript намагається знайти їх в прототипі.
-- Операції по запису/видаленню здійснюються безпосередньо на об’єкті. Ці операції не використовують прототипи (припускаючи, що це властивість даних, а не setter).
-- Якщо ми викликаємо `obj.method()`, і при цьому, `method` береться з прототипу, ключове слово `this` вказує на `obj`. Таким чином, методи завжди працюють з поточним об’єктом, навіть, якщо ці методи успадковані.
-- Цикл `for..in` ітерує як по власних властивостям так і по успадкованих. Усі інші методи з отримання пар ключ/значення діють тільки на власних об’єктах.
+- Об'єкт, на який посилається властивість `[[Prototype]]` називається "прототип".
+- Якщо ми хочемо прочитати властивості об'єкта `obj` чи викликаємо метод, який не існує, тоді JavaScript намагається знайти їх в прототипі.
+- Операції по запису/видаленню здійснюються безпосередньо на об'єкті. Ці операції не використовують прототипи (припускаючи, що це властивість даних, а не setter).
+- Якщо ми викликаємо `obj.method()`, і при цьому, `method` береться з прототипу, ключове слово `this` вказує на `obj`. Таким чином, методи завжди працюють з поточним об'єктом, навіть, якщо ці методи успадковані.
+- Цикл `for..in` ітерує як по власних властивостям так і по успадкованих. Усі інші методи з отримання пар ключ/значення діють тільки на власних об'єктах.
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
index 7a5694d4d..3269022fd 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -3,17 +3,17 @@
 
 1. `true`. 
 
-    Визначення `Rabbit.prototype` встановлює властивість `[[Prototype]]` для новоствореного об’єкта, але це жодним чином не впливає на вже існуючий об’єкт.
+    Визначення `Rabbit.prototype` встановлює властивість `[[Prototype]]` для новоствореного об'єкта, але це жодним чином не впливає на вже існуючий об'єкт.
 
 2. `false`. 
 
-    Об’єкти призначаються шляхом посилання на них. Об’єкт з властивістю `Rabbit.prototype` не дублюється, це є той самий об’єкт на який посилаються як через `Rabbit.prototype` так і через властивість `[[Prototype]]` об’єкта `rabbit`. 
+    Об'єкти призначаються шляхом посилання на них. Об'єкт з властивістю `Rabbit.prototype` не дублюється, це є той самий об'єкт на який посилаються як через `Rabbit.prototype` так і через властивість `[[Prototype]]` об'єкта `rabbit`. 
 
-    А отже, коли ми змінюємо контент такого об’єкта через посилання, такі зміни стають видимі і через інші посилання.
+    А отже, коли ми змінюємо контент такого об'єкта через посилання, такі зміни стають видимі і через інші посилання.
 
 3. `true`.
 
-    Усі `delete` операції застосовуються безпосередньо на самому об'єкті. Тут `delete rabbit.eats` намагається видалити властивість `eats` з об’єкта `rabbit`, але такої властивості немає. А тому така операція не має ніякого ефекту.
+    Усі `delete` операції застосовуються безпосередньо на самому об'єкті. Тут `delete rabbit.eats` намагається видалити властивість `eats` з об'єкта `rabbit`, але такої властивості немає. А тому така операція не має ніякого ефекту.
 
 4. `undefined`.
 
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
index d0bb4358c..34dfb5db0 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Заміна властивості "prototype"
 
-В коді, що показаний нижче, ми створюємо об’єкт `new Rabbit` і потім міняємо його прототип.
+В коді, що показаний нижче, ми створюємо об'єкт `new Rabbit` і потім міняємо його прототип.
 
 На початку, маємо цей код:
 
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
index 558b03843..ac10db4d7 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -15,7 +15,7 @@ alert( user2.name ); // Pete (працює!)
 
 Код працює, тому що `User.prototype.constructor == User`.
 
-..Але якщо хтось, якщо можна так виразитись, перезапише `User.prototype` і забуде додати властивість `constructor` в посиланні властивості об’єкта `User`, тоді цей код не буде працювати правильно.
+..Але якщо хтось, якщо можна так виразитись, перезапише `User.prototype` і забуде додати властивість `constructor` в посиланні властивості об'єкта `User`, тоді цей код не буде працювати правильно.
 
 Наприклад:
 
@@ -37,13 +37,13 @@ alert( user2.name ); // undefined
 
 Ось тут пояснення як `new user.constructor('Pete')` працює:
 
-1. Спочатку, здійснюється пошук у властивості `constructor` об’єкта `user`. Нічого не знаходять.
-2. Потім переключаються на ланцюжок прототипу. Прототипом для об’єкта `user` є `User.prototype`, і він також не має властивості `constructor` (тому що ми "забули" визначити його правильним чином!).
-3. Йдучи далі по ланцюжку прототипу, визначаємо, що `User.prototype` є простий об’єкт, його прототипом є вбудований глобальний `Object.prototype`. 
-4. Врешті, для вбудованого `Object.prototype`, є вбудований конструктор глобального об’єкта `Object.prototype.constructor == Object` от він і використовується.
+1. Спочатку, здійснюється пошук у властивості `constructor` об'єкта `user`. Нічого не знаходять.
+2. Потім переключаються на ланцюжок прототипу. Прототипом для об'єкта `user` є `User.prototype`, і він також не має властивості `constructor` (тому що ми "забули" визначити його правильним чином!).
+3. Йдучи далі по ланцюжку прототипу, визначаємо, що `User.prototype` є простий об'єкт, його прототипом є вбудований глобальний `Object.prototype`. 
+4. Врешті, для вбудованого `Object.prototype`, є вбудований конструктор глобального об'єкта `Object.prototype.constructor == Object` от він і використовується.
 
 Таким чином, в кінці, ми отримуємо `let user2 = new Object('Pete')`. 
 
 Ймовірно, це не те, що нам потрібно. Ми би хотіли стоврити `new User`, а не `new Object`. Це і є наслідки пропуску властивості `constructor`.
 
-(на випадок, якщо вас зацікавить, виклик `new Object(...)` перетворює його аргументи на об’єкт. Це в теорії, але на практиці ніхто не викликає `new Object` з аргументами; і загалом, не використовується узагалі `new Object` для створення нових об’єктів).
\ No newline at end of file
+(на випадок, якщо вас зацікавить, виклик `new Object(...)` перетворює його аргументи на об'єкт. Це в теорії, але на практиці ніхто не викликає `new Object` з аргументами; і загалом, не використовується узагалі `new Object` для створення нових об'єктів).
\ No newline at end of file
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
index fd762b072..0e8f63b0b 100644
--- a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
+++ b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Створення нового об’єкта з одинаковим конструктором
+# Створення нового об'єкта з одинаковим конструктором
 
-Уявіть собі, у нас є довільний об’єкт `obj`, який створений функцією-конструктором -- ми не знаємо яким саме конструктором, але потрібно створити новий об’єкт використовуючи той самий конструктор.
+Уявіть собі, у нас є довільний об'єкт `obj`, який створений функцією-конструктором -- ми не знаємо яким саме конструктором, але потрібно створити новий об'єкт використовуючи той самий конструктор.
 
-Чи можна створити новий об’єкт ось так?
+Чи можна створити новий об'єкт ось так?
 
 ```js
 let obj2 = new obj.constructor();
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index c834b3941..889f60aa6 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,8 +1,8 @@
 # F.prototype
 
-Як відомо, ми можемо створювати нові об’єкти за допомогою функції-конструктора, ось так `new F()`.
+Як відомо, ми можемо створювати нові об'єкти за допомогою функції-конструктора, ось так `new F()`.
 
-Якщо розглядати `F.prototype` як властивість об’єкта, то оператор `new` автоматично створює приховану властивість `[[Prototype]]` для новоствореного об’єкта.
+Якщо розглядати `F.prototype` як властивість об'єкта, то оператор `new` автоматично створює приховану властивість `[[Prototype]]` для новоствореного об'єкта.
 
 ```smart
 JavaScript мала можливість успадкування властивостей через прототипи ще від самого початку її створення. Це було одним з головних особливостей мови.
@@ -10,7 +10,7 @@ JavaScript мала можливість успадкування властив
 Але в ті часи, не було прямого доступу до прототипів. Тільки одна річ, яка працювала надійно, була властивість функції-конструктора `"prototype"` , яка і описана в цій главі. Ось чому ще існує багато коду де цю властивість використовують.
 ```
 
-Зауважте, що `F.prototype` тут означає звичайну властивість, яку назвали `"prototype"` в об’єкті `F`. Це звучить дуже співзвучно з терміном "prototype", але тут це означає всього лиш звичайне ім’я властивості.
+Зауважте, що `F.prototype` тут означає звичайну властивість, яку назвали `"prototype"` в об'єкті `F`. Це звучить дуже співзвучно з терміном "prototype", але тут це означає всього лиш звичайне ім'я властивості.
 
 Ось приклад:
 
@@ -32,7 +32,7 @@ let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
 alert( rabbit.eats ); // true
 ```
 
-Вираз `Rabbit.prototype = animal` дослівно означає наступне: "коли `new Rabbit` створено, його властивість `[[Prototype]]` посилається на об’єкт `animal`".
+Вираз `Rabbit.prototype = animal` дослівно означає наступне: "коли `new Rabbit` створено, його властивість `[[Prototype]]` посилається на об'єкт `animal`".
 
 Ось кінцева картинка:
 
@@ -41,16 +41,16 @@ alert( rabbit.eats ); // true
 На картинці, `"prototype"` що показана горизонтальною стрілкою, це звичайна властивість, а `[[Prototype]]`показана вертикальною, що означає `rabbit` успадковує властивості від свого прототипа `animal`.
 
 ```smart header="`F.prototype` використовується тільки у разі використання функції-конструктора `new F`"
-Властивість `F.prototype` використовується коли буде викликано `new F`, і створює властивість `[[Prototype]]` для нового об’єкта.
+Властивість `F.prototype` використовується коли буде викликано `new F`, і створює властивість `[[Prototype]]` для нового об'єкта.
 
-Якщо властивість `F.prototype` після створення змінюється (`F.prototype = <another object>`), тоді і новий об’єкт який створюється функцією-конструктором `new F` буде мати посилання `[[Prototype]]` на інший об’єкт, а в раніше створених об’єктах є свої прототипи які були визначені ще  при їх створенні.
+Якщо властивість `F.prototype` після створення змінюється (`F.prototype = <another object>`), тоді і новий об'єкт який створюється функцією-конструктором `new F` буде мати посилання `[[Prototype]]` на інший об'єкт, а в раніше створених об'єктах є свої прототипи які були визначені ще  при їх створенні.
 ```
 
 ## Типове значення F.prototype, властивості конструктора
 
 Кожна функція має властивість `"prototype"` навіть якщо ми цю властивість самі не прописуємо. Тобто вона існує за замовчуванням, або ця властивість є типовою.
 
-В свою чергу, така типова властивість `"prototype"` представляє собою об’єкт, який має єдину властивість з назвою `constructor`, що зворотньо посилається на назву самої функції-конструктора.
+В свою чергу, така типова властивість `"prototype"` представляє собою об'єкт, який має єдину властивість з назвою `constructor`, що зворотньо посилається на назву самої функції-конструктора.
 
 Ось як тут:
 
@@ -74,7 +74,7 @@ function Rabbit() {}
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Отже, якщо ми нічого не робимо з властивістю `constructor` то вона є доступна для всіх об’єктів rabbits через `[[Prototype]]`:
+Отже, якщо ми нічого не робимо з властивістю `constructor` то вона є доступна для всіх об'єктів rabbits через `[[Prototype]]`:
 
 ```js run
 function Rabbit() {}
@@ -88,7 +88,7 @@ alert(rabbit.constructor == Rabbit); // true (від прототипу)
 
 ![](rabbit-prototype-constructor.svg)
 
-Ми можемо використовувати властивість `constructor` для створення нових об’єктів використовуючи той самий конструктор, який вже існує.
+Ми можемо використовувати властивість `constructor` для створення нових об'єктів використовуючи той самий конструктор, який вже існує.
 
 Як тут:
 
@@ -105,7 +105,7 @@ let rabbit2 = new rabbit.constructor("Black Rabbit");
 */!*
 ```
 
-Це дуже практично у випадку наявності об’єкта, але не знаємо за допомогою якого саме конструктора той об’єкт був створений (для прикладу який був імпортований з якоїсь бібліотеки), а нам потрібно створити новий об’єкт по типу того, що вже існує.
+Це дуже практично у випадку наявності об'єкта, але не знаємо за допомогою якого саме конструктора той об'єкт був створений (для прикладу який був імпортований з якоїсь бібліотеки), а нам потрібно створити новий об'єкт по типу того, що вже існує.
 
 Але самим важливим моментом щодо `"constructor"` є те, що...
 
@@ -156,15 +156,15 @@ Rabbit.prototype = {
 
 ## Підсумок
 
-В цьому розділі було коротко описано шлях для встановлення прихованої властивості `[[Prototype]]` об’єктів, які були створені за допомогою функції-конструктора. Пізніше, буде надано більше прикладів коду, які покладаються на ці властивості.
+В цьому розділі було коротко описано шлях для встановлення прихованої властивості `[[Prototype]]` об'єктів, які були створені за допомогою функції-конструктора. Пізніше, буде надано більше прикладів коду, які покладаються на ці властивості.
 
 Все є простим, тільки додамо декілька штрихів для того щоб усе було зрозуміло:
 
-- Властивість об’єкта `F.prototype` (ні в якому разі не `[[Prototype]]`) встановлює приховану властивість `[[Prototype]]` нового об’єкта, тільки тоді, коли буде викликана через `new F()`.
-- Значення властивості `F.prototype` може бути, або посиланням на об’єкт, або `null`: інші значення не працюють.
+- Властивість об'єкта `F.prototype` (ні в якому разі не `[[Prototype]]`) встановлює приховану властивість `[[Prototype]]` нового об'єкта, тільки тоді, коли буде викликана через `new F()`.
+- Значення властивості `F.prototype` може бути, або посиланням на об'єкт, або `null`: інші значення не працюють.
 - Тільки властивість `"prototype"` має такий спеціальний ефект: може встановлюватись в конструкторі та може викликатись через оператор `new`.
 
-У звичайних об’єктах властивість `prototype` не є чимось спеціальним:
+У звичайних об'єктах властивість `prototype` не є чимось спеціальним:
 ```js
 let user = {
   name: "John",
@@ -172,4 +172,4 @@ let user = {
 };
 ```
 
-За замовчуванням, усі функції мають `F.prototype = { constructor: F }`, і ми можемо отримати конструктор об’єкта через його властивість `"constructor"`.
+За замовчуванням, усі функції мають `F.prototype = { constructor: F }`, і ми можемо отримати конструктор об'єкта через його властивість `"constructor"`.
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
index 02196183f..c0a435ff6 100644
--- a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
+++ b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md
@@ -16,9 +16,9 @@ function f(a, b) {
 f.defer(1000)(1, 2); // показує 3 після 1 сек
 ```
 
-Будь ласка, зверніть увагу: ми використовуємо `this` в `f.apply`, щоб наше декорування працювало для методів об’єкта.
+Будь ласка, зверніть увагу: ми використовуємо `this` в `f.apply`, щоб наше декорування працювало для методів об'єкта.
 
-Отже, якщо функція-обгортка викликається як метод об’єкта, то `this` передається до оригінального методу `f`.
+Отже, якщо функція-обгортка викликається як метод об'єкта, то `this` передається до оригінального методу `f`.
 
 ```js run
 Function.prototype.defer = function(ms) {
diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index a941c7181..ede081149 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -2,11 +2,11 @@
 
 Властивість `"prototype"` широко використовується ядром самого JavaScript. Її використовують всі вбудовані функції конструктора.
 
-Спочатку ми розглянемо деталі, а потім розберемося як додати нових можливостей вбудованим об’єктам.
+Спочатку ми розглянемо деталі, а потім розберемося як додати нових можливостей вбудованим об'єктам.
 
 ## Object.prototype
 
-Скажімо, ми виводимо порожній об’єкт:
+Скажімо, ми виводимо порожній об'єкт:
 
 ```js run
 let obj = {};
@@ -15,13 +15,13 @@ alert( obj ); // "[object Object]" ?
 
 Де код, який генерує рядок `"[object Object]"`? Це вбудований метод `toString`, але де це? `obj` порожній!
 
-...але коротке позначення `obj = {}` -- це те саме, що `obj = new Object()`, де `Object` є вбудованою функцією-конструктором об’єкта, з власним `prototype`, що посилається на величезний об’єкт з `toString` та іншими методами.
+...але коротке позначення `obj = {}` -- це те саме, що `obj = new Object()`, де `Object` є вбудованою функцією-конструктором об'єкта, з власним `prototype`, що посилається на величезний об'єкт з `toString` та іншими методами.
 
 Ось що відбувається:
 
 ![](object-prototype.svg)
 
-Коли викликається `new Object()` (або створюється літеральний об’єкт `{...}`), у властивість `[[Prototype]]` встановлюється `Object.prototype` згідно з правилом, який ми обговорювали у попередньому розділі:
+Коли викликається `new Object()` (або створюється літеральний об'єкт `{...}`), у властивість `[[Prototype]]` встановлюється `Object.prototype` згідно з правилом, який ми обговорювали у попередньому розділі:
 
 ![](object-prototype-1.svg)
 
@@ -46,13 +46,13 @@ alert(Object.prototype.__proto__); // null
 
 ## Інші вбудовані прототипи
 
-Інші вбудовані об’єкти, такі як `Array`, `Date`, `Function` та інші також зберігають методи у прототипах.
+Інші вбудовані об'єкти, такі як `Array`, `Date`, `Function` та інші також зберігають методи у прототипах.
 
 Наприклад, коли ми створюємо масив `[1, 2, 3]`, внутрішньо використовується конструктор `new Array()`. Таким чином `Array.prototype` стає його прототипом і надає свої методи. Це дуже ефективно.
 
-За специфікацією, на вершині ієрархії всі вбудовані прототипи мають `Object.prototype`. Ось чому деякі люди кажуть, що "все успадковується від об’єктів".
+За специфікацією, на вершині ієрархії всі вбудовані прототипи мають `Object.prototype`. Ось чому деякі люди кажуть, що "все успадковується від об'єктів".
 
-Ось загальна картина (для 3 вбудованих об’єктів):
+Ось загальна картина (для 3 вбудованих об'єктів):
 
 ![](native-prototypes-classes.svg)
 
@@ -84,29 +84,29 @@ alert(arr); // 1,2,3 <-- результат Array.prototype.toString
 ![](native-prototypes-array-tostring.svg)
 
 
-Інструменти браузера, такі як консоль розробника Chrome, також показують наслідування (можливо, доведеться використовувати `console.dir` для вбудованих об’єктів):
+Інструменти браузера, такі як консоль розробника Chrome, також показують наслідування (можливо, доведеться використовувати `console.dir` для вбудованих об'єктів):
 
 ![](console_dir_array.png)
 
-Інші вбудовані об’єкти також працюють так само. Навіть функції -- вони є об’єктами вбудованого конструктора `Function`, а їхні методи (`call`/`apply` та інші) беруться з `Function.prototype`. Функції мають власні `toString`.
+Інші вбудовані об'єкти також працюють так само. Навіть функції -- вони є об'єктами вбудованого конструктора `Function`, а їхні методи (`call`/`apply` та інші) беруться з `Function.prototype`. Функції мають власні `toString`.
 
 ```js run
 function f() {}
 
 alert(f.__proto__ == Function.prototype); // true
-alert(f.__proto__.__proto__ == Object.prototype); // true, успадковується від об’єктів
+alert(f.__proto__.__proto__ == Object.prototype); // true, успадковується від об'єктів
 ```
 
 ## Примітиви
 
 Найскладніша річ відбувається з рядками, числами та бульовими значеннями.
 
-Як ми пам’ятаємо, вони не є об’єктами. Але якщо ми спробуємо отримати доступ до їх властивостей, створюються тимчасові об’єкти-обгортки, використовуючи вбудовані конструктори `String`, `Number` та `Boolean`. Вони забезпечують методи, а після цього зникають.
+Як ми пам'ятаємо, вони не є об'єктами. Але якщо ми спробуємо отримати доступ до їх властивостей, створюються тимчасові об'єкти-обгортки, використовуючи вбудовані конструктори `String`, `Number` та `Boolean`. Вони забезпечують методи, а після цього зникають.
 
-Ці об’єкти створюються приховано від нас, і більшість рушіїв оптимізують їх, але специфікація описує це саме таким чином.Методи цих об’єктів також знаходяться у прототипах, доступних як `String.prototype`, `Number.prototype` та `Boolean.prototype`.
+Ці об'єкти створюються приховано від нас, і більшість рушіїв оптимізують їх, але специфікація описує це саме таким чином.Методи цих об'єктів також знаходяться у прототипах, доступних як `String.prototype`, `Number.prototype` та `Boolean.prototype`.
 
-```warn header="Значення `null` та `undefined` не мають жодних об’єктів-обгорток"
-Спеціальні значення `null`  та `undefined` стоять окремо. Вони не мають об’єктів-обгорток, тому для них недоступні методи та властивості. І вони також не мають відповідних прототипів.
+```warn header="Значення `null` та `undefined` не мають жодних об'єктів-обгорток"
+Спеціальні значення `null`  та `undefined` стоять окремо. Вони не мають об'єктів-обгорток, тому для них недоступні методи та властивості. І вони також не мають відповідних прототипів.
 ```
 
 ## Зміна вбудованих прототипів [#native-prototype-change]
@@ -159,11 +159,11 @@ alert( "Ла".repeat(3) ); // ЛаЛаЛа
 
 У розділі <info:call-apply-decorators#method-borrowing> ми говорили про запозиченння методів.
 
-Це коли ми приймаємо метод від одного об’єкта і копіюємо його в інший.
+Це коли ми приймаємо метод від одного об'єкта і копіюємо його в інший.
 
 Деякі методи вбудованих прототипів часто позичаються.
 
-Наприклад, якщо ми створимо об’єкт, подібний до масиву, ми можемо скопіювати деякі методи `Array` до нього.
+Наприклад, якщо ми створимо об'єкт, подібний до масиву, ми можемо скопіювати деякі методи `Array` до нього.
 
 Приклад:
 
@@ -181,18 +181,18 @@ obj.join = Array.prototype.join;
 alert( obj.join(',') ); // Привіт,світ!
 ```
 
-Це працює, оскільки для внутрішнього алгоритму вбудованого методу `join` важливі тільки правильні індекси та властивість `length`. Це метод не перевіряє, чи дійсно об’єкт є масивом. Багато вбудованих методів працюють подібним чином.
+Це працює, оскільки для внутрішнього алгоритму вбудованого методу `join` важливі тільки правильні індекси та властивість `length`. Це метод не перевіряє, чи дійсно об'єкт є масивом. Багато вбудованих методів працюють подібним чином.
 
 Ще одна можливість полягає в тому, щоб успадкуватися від масиву, встановлюючи `obj.__ proto__` як `Array.prototype`, таким чином всі методи `Array` автоматично будуть доступні в `obj`.
 
-Але це неможливо, якщо `obj` вже успадковує від іншого об’єкта. Пам’ятайте, що ми можемо успадкувати від одного об’єкта за один раз.
+Але це неможливо, якщо `obj` вже успадковує від іншого об'єкта. Пам'ятайте, що ми можемо успадкувати від одного об'єкта за один раз.
 
-Запозичення методів є гнучкими, воно дозволяє змішувати функції з різних об’єктів, якщо це необхідно.
+Запозичення методів є гнучкими, воно дозволяє змішувати функції з різних об'єктів, якщо це необхідно.
 
 ## Підсумки
 
-- Всі вбудовані об’єкти слідують за однією моделлю:
+- Всі вбудовані об'єкти слідують за однією моделлю:
     - Методи зберігаються у прототипі (`Array.prototype`, `Object.prototype`, `Date.prototype` та ін.)
-    - Сам об’єкт зберігає лише дані (елементи масиву, властивості об’єкта, дату)
-- Природу також зберігають методи у прототипах об’єктів-обгорток: `Number.prototype`, `String.prototype` and `Boolean.prototype`. Тільки `undefined` і `null` не мають об’єктів-обгорток
+    - Сам об'єкт зберігає лише дані (елементи масиву, властивості об'єкта, дату)
+- Природу також зберігають методи у прототипах об'єктів-обгорток: `Number.prototype`, `String.prototype` and `Boolean.prototype`. Тільки `undefined` і `null` не мають об'єктів-обгорток
 - Вбудовані прототипи можуть бути змінені або доповнені новими методами. Але їх не рекомендується змінювати. Єдиний допустимий випадок, мабуть, коли ми додаємо якийсь новий стандарт, котрий ще не підтримується рушієм JavaScript
diff --git a/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
index f8e0dea77..65c96a3c1 100644
--- a/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
+++ b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md
@@ -1,7 +1,7 @@
 
-Метод може взяти всі перелічувані ключі об’єкта за допомогою `Object.keys` та вивести їх перелік.
+Метод може взяти всі перелічувані ключі об'єкта за допомогою `Object.keys` та вивести їх перелік.
 
-Для того щоб зробити метод `toString` не перлічуваним, визначимо його використовуючи дескриптор властивості. Синтаксис `Object.create` дозволяє нам надати об’єкту дескриптори властивостей як другий аргумент.
+Для того щоб зробити метод `toString` не перлічуваним, визначимо його використовуючи дескриптор властивості. Синтаксис `Object.create` дозволяє нам надати об'єкту дескриптори властивостей як другий аргумент.
 
 ```js run
 *!*
diff --git a/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md
index 9a03c7cc9..1dff40250 100644
--- a/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md
+++ b/1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Додайте toString до об’єкту-словника
+# Додайте toString до об'єкту-словника
 
-Дано об’єкт `dictionary`, створений за допомогою `Object.create(null)`, щоб зберегти будь-які пари `ключ/значення`.
+Дано об'єкт `dictionary`, створений за допомогою `Object.create(null)`, щоб зберегти будь-які пари `ключ/значення`.
 
-Додайте метод `dictionary.toString()` до об’єкта, який повертає перелік ключів через кому. Метод `toString` не повинен показуватися, якщо застосувати до об’єкта цикл `for..in`.
+Додайте метод `dictionary.toString()` до об'єкта, який повертає перелік ключів через кому. Метод `toString` не повинен показуватися, якщо застосувати до об'єкта цикл `for..in`.
 
 Тут показано як це має працювати:
 
@@ -19,7 +19,7 @@ let dictionary = Object.create(null);
 
 // додаємо певні дані
 dictionary.apple = "Яблуко";
-dictionary.__proto__ = "тест"; // __proto__ тут є звичайною властивістю об’єкта
+dictionary.__proto__ = "тест"; // __proto__ тут є звичайною властивістю об'єкта
 
 // тільки ключі apple та __proto__ показуються в циклі
 for(let key in dictionary) {
diff --git a/1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md
index d3467b0bc..2292f552d 100644
--- a/1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md
+++ b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md
@@ -1,5 +1,5 @@
 
-Перший виклик має `this == rabbit`, інші мають `this` рівний `Rabbit.prototype`, тому що це об’єкт перед крапкою.
+Перший виклик має `this == rabbit`, інші мають `this` рівний `Rabbit.prototype`, тому що це об'єкт перед крапкою.
 
 Таким чином тільки перший виклик покаже `Кріль`, інші покажуть `undefined`:
 
diff --git a/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
index 13f1721cc..3639378cf 100644
--- a/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
+++ b/1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Різниця між викликами
 
-Створимо новий об’єкт `rabbit`:
+Створимо новий об'єкт `rabbit`:
 
 ```js
 function Rabbit(name) {
diff --git a/1-js/08-prototypes/04-prototype-methods/article.md b/1-js/08-prototypes/04-prototype-methods/article.md
index 99dc2c47b..53509f857 100644
--- a/1-js/08-prototypes/04-prototype-methods/article.md
+++ b/1-js/08-prototypes/04-prototype-methods/article.md
@@ -1,5 +1,5 @@
 
-# Методи прототипів, об’єкти без __proto__
+# Методи прототипів, об'єкти без __proto__
 
 В першій главі цього розділу, ми згадували сучасні методи роботи з прототипом.
 
@@ -7,14 +7,14 @@
 
 Сучасні методи отримання/встановлення прототипу:
 
-- [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) -- повертає значення `[[Prototype]]` об’єкту `obj`.
-- [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) -- встановлює значення `[[Prototype]]` об’єкту `obj` рівне `proto`.
+- [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) -- повертає значення `[[Prototype]]` об'єкту `obj`.
+- [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) -- встановлює значення `[[Prototype]]` об'єкту `obj` рівне `proto`.
 
-Єдине використання `__proto__`, яке не викликає негативного ставлення, це як властивість під час створення нового об’єкта: `{ __proto__: ... }`.
+Єдине використання `__proto__`, яке не викликає негативного ставлення, це як властивість під час створення нового об'єкта: `{ __proto__: ... }`.
 
 Хоча і для цього є спеціальний метод:
 
-- [Object.create(proto, [descriptors])](mdn:js/Object/create) -- створює порожній об’єкт із заданим `proto` як `[[Prototype]]` і необов’язковими дескрипторами властивостей.
+- [Object.create(proto, [descriptors])](mdn:js/Object/create) -- створює порожній об'єкт із заданим `proto` як `[[Prototype]]` і необов'язковими дескрипторами властивостей.
 
 Наприклад:
 
@@ -23,7 +23,7 @@ let animal = {
   eats: true
 };
 
-// створюється новий об’єкт з прототипом animal
+// створюється новий об'єкт з прототипом animal
 *!*
 let rabbit = Object.create(animal); // same as {__proto__: animal}
 */!*
@@ -35,13 +35,13 @@ alert(Object.getPrototypeOf(rabbit) === animal); // true
 */!*
 
 *!*
-Object.setPrototypeOf(rabbit, {}); // змінює прототип об’єкту rabbit на {}
+Object.setPrototypeOf(rabbit, {}); // змінює прототип об'єкту rabbit на {}
 */!*
 ```
 
-`Object.create` має необов’язковий другий аргумент: дескриптори властивостей.
+`Object.create` має необов'язковий другий аргумент: дескриптори властивостей.
 
-Ми можемо надати додаткові властивості новому об’єкту, як тут:
+Ми можемо надати додаткові властивості новому об'єкту, як тут:
 
 ```js run
 let animal = {
@@ -59,7 +59,7 @@ alert(rabbit.jumps); // true
 
 Формат дескрипторів описаний в цій главі <info:property-descriptors>.
 
-Ми можемо використати `Object.create`, щоб клонувати об’єкт ефективніше ніж циклом `for..in`:
+Ми можемо використати `Object.create`, щоб клонувати об'єкт ефективніше ніж циклом `for..in`:
 
 ```js
 let clone = Object.create(
@@ -67,7 +67,7 @@ let clone = Object.create(
 );
 ```
 
-Таким чином ми створюємо справжню копію об’єкта `obj`, включаючи всі властивості: перелічувані та не перелічувані, сетери/гетери -- з правильним значенням `[[Prototype]]`.
+Таким чином ми створюємо справжню копію об'єкта `obj`, включаючи всі властивості: перелічувані та не перелічувані, сетери/гетери -- з правильним значенням `[[Prototype]]`.
 
 
 ## Коротка історія
@@ -78,9 +78,9 @@ let clone = Object.create(
 
 Прототипна спадковість була в мові з самого початку, але способи керування нею розвивалися з часом.
 
-- Властивість `prototype` функції-конструктора працювала з дуже давніх часів. Це найстаріший спосіб створення об’єктів із заданим прототипом.
-- Пізніше, в 2012 році, метод `Object.create` став стандартом. Це дало можливість створювати об’єкти з певним прототипом, проте не дозволяло отримувати або встановлювати його. Тому браузери реалізували не стандартний аксесор `__proto__`, що дозволяв користувачу отримувати та встановлювати прототип в будь-який час, щоб надати розробникам більше гнучкості.
-- Ще пізніше, в 2015 році, методи `Object.setPrototypeOf` та `Object.getPrototypeOf` були додані до стандарту, для того, щоб виконувати аналогічну функціональність як і `__proto__`. Оскільки `__proto__` було широко реалізовано, воно згадується в Annex B стандарту як не обов’язкове для не-браузерних середовищ, але вважається свого роду застарілим.
+- Властивість `prototype` функції-конструктора працювала з дуже давніх часів. Це найстаріший спосіб створення об'єктів із заданим прототипом.
+- Пізніше, в 2012 році, метод `Object.create` став стандартом. Це дало можливість створювати об'єкти з певним прототипом, проте не дозволяло отримувати або встановлювати його. Тому браузери реалізували не стандартний аксесор `__proto__`, що дозволяв користувачу отримувати та встановлювати прототип в будь-який час, щоб надати розробникам більше гнучкості.
+- Ще пізніше, в 2015 році, методи `Object.setPrototypeOf` та `Object.getPrototypeOf` були додані до стандарту, для того, щоб виконувати аналогічну функціональність як і `__proto__`. Оскільки `__proto__` було широко реалізовано, воно згадується в Annex B стандарту як не обов'язкове для не-браузерних середовищ, але вважається свого роду застарілим.
 - Пізніше, у 2022 році, було офіційно дозволено використовувати `__proto__` в об'єктних літералах `{...}` (винесено з Annex B), але не як геттер/сеттер `obj.__proto__` (ця можливість все ще в Annex B).
 
 Чому `__proto__` було замінено функціями `getPrototypeOf/setPrototypeOf`?
@@ -95,15 +95,15 @@ let clone = Object.create(
 
 І незабаром ми отримаємо відповідь.
 
-```warn header="Не змінюйте `[[Prototype]]` в існуючих об’єктів, якщо швидкість важлива"
-Технічно, ми можемо отримати/встановити `[[Prototype]]` в будь-який момент. Але зазвичай ми тільки встановлюємо його один раз під час створення об’єкту та більше не змінюємо: `rabbit` наслідується від `animal` і це не зміниться.
+```warn header="Не змінюйте `[[Prototype]]` в існуючих об'єктів, якщо швидкість важлива"
+Технічно, ми можемо отримати/встановити `[[Prototype]]` в будь-який момент. Але зазвичай ми тільки встановлюємо його один раз під час створення об'єкту та більше не змінюємо: `rabbit` наслідується від `animal` і це не зміниться.
 
-JavaScript рушій є високо оптимізованим для цього. Зміна прототипу "на льоту" за допомогою `Object.setPrototypeOf` або `obj.__proto__=` дуже повільна операція, яка порушує внутрішню оптимізацію для операції з доступу до властивості об’єкта. Щоб уникнути цього, ви маєте розуміти що ви робите і для чого або швидкодія виконання JavaScript коду повністю не важлива для вас.
+JavaScript рушій є високо оптимізованим для цього. Зміна прототипу "на льоту" за допомогою `Object.setPrototypeOf` або `obj.__proto__=` дуже повільна операція, яка порушує внутрішню оптимізацію для операції з доступу до властивості об'єкта. Щоб уникнути цього, ви маєте розуміти що ви робите і для чого або швидкодія виконання JavaScript коду повністю не важлива для вас.
 ```
 
-## "Прості" об’єкти [#very-plain]
+## "Прості" об'єкти [#very-plain]
 
-Як ми знаємо, об’єкти можуть використовуватися як асоціативні масиви для зберігання пар ключ/значення.
+Як ми знаємо, об'єкти можуть використовуватися як асоціативні масиви для зберігання пар ключ/значення.
 
 ...Проте якщо ми спробуємо зберегти *створені користувачем* ключі в ньому (наприклад, словник з користувацьким вводом), ми можемо спостерігати цікавий збій: усі ключі працюють правильно окрім `"__proto__"`.
 
@@ -120,19 +120,19 @@ alert(obj[key]); // [object Object], не "певне значення"!
 
 Тут, якщо користувач вводить `__proto__`, призначення в рядку 4 ігнорується!
 
-Це, безумовно, може бути дивним для нерозробника, але досить зрозумілим для нас. Властивість `__proto__` є особливою: вона має бути або об’єктом, або `null`. Рядок не може стати прототипом. Ось чому призначення рядка `__proto__` ігнорується.
+Це, безумовно, може бути дивним для нерозробника, але досить зрозумілим для нас. Властивість `__proto__` є особливою: вона має бути або об'єктом, або `null`. Рядок не може стати прототипом. Ось чому призначення рядка `__proto__` ігнорується.
 
 Проте ми не намагалися реалізувати таку поведінку. Ми хотіли зберегти пари ключ/значення і при цьому ключ з назвою `"__proto__"` не зберігся. Тому це помилка!
 
-Тут наслідки не такі страшні. Але в інших випадках ми можемо зберігати об’єкти замість рядків у `obj`, і тоді прототип справді буде змінено. У результаті код відпрацює зовсім несподіваним чином.
+Тут наслідки не такі страшні. Але в інших випадках ми можемо зберігати об'єкти замість рядків у `obj`, і тоді прототип справді буде змінено. У результаті код відпрацює зовсім несподіваним чином.
 
 Найгірше в цьому -- зазвичай розробники не задумаються над тим, що така ситуація взагалі можлива. Це робить подібні помилки важкими для виявлення і перетворюються їх у вразливості, особливо коли JavaScript використовується на стороні серверу.
 
-Неочікувані речі також можуть статися під час призначення `obj.toString`, оскільки це вбудований метод об’єкта.
+Неочікувані речі також можуть статися під час призначення `obj.toString`, оскільки це вбудований метод об'єкта.
 
 Як ми можемо уникнути цієї проблеми?
 
-В першу чергу, для зберігання ми можемо просто використовувати `Map` замість простих об’єктів, тоді все працює правильно:
+В першу чергу, для зберігання ми можемо просто використовувати `Map` замість простих об'єктів, тоді все працює правильно:
 
 ```js run
 let map = new Map();
@@ -145,9 +145,9 @@ alert(map.get(key)); // "some value" (як і передбачалося)
 
 ...Але синтаксис `Object` часто більш привабливий, оскільки він більш стислий.
 
-На щастя, ми *можемо* використовувати об’єкти, тому що творці мови давно подумали про цю проблему.
+На щастя, ми *можемо* використовувати об'єкти, тому що творці мови давно подумали про цю проблему.
 
-`__proto__` не є властивістю об’єкту, але є аксесором `Object.prototype`:
+`__proto__` не є властивістю об'єкту, але є аксесором `Object.prototype`:
 
 ![](object-prototype-2.svg)
 
@@ -155,7 +155,7 @@ alert(map.get(key)); // "some value" (як і передбачалося)
 
 Як було сказано на початку цього розділу: `__proto__` це спосіб доступу до `[[Prototype]]`, але не є самим `[[Prototype]]`.
 
-Тепер, коли ми хочемо використати об’єкт як асоціативний масив та уникнути таких проблем, ми можемо зробити це за допомогою невеликої хитрості:
+Тепер, коли ми хочемо використати об'єкт як асоціативний масив та уникнути таких проблем, ми можемо зробити це за допомогою невеликої хитрості:
 
 ```js run
 *!*
@@ -169,15 +169,15 @@ obj[key] = "певне значення";
 alert(obj[key]); // "певне значення"
 ```
 
-`Object.create(null)` створює пустий об’єкт без прототипу (`[[Prototype]]` дорівнює `null`):
+`Object.create(null)` створює пустий об'єкт без прототипу (`[[Prototype]]` дорівнює `null`):
 
 ![](object-prototype-null.svg)
 
 Таким чином, відсутні наслідувані гетер/сетер для `__proto__`. Тепер ми працюємо зі звичайною властивістю, тому приклад вище працює правильно.
 
-Ми можемо називати такі об’єкти "простими" або "чистим словниковим" об’єктом, тому що вони навіть простіше ніж звичайні об’єкти `{...}`.
+Ми можемо називати такі об'єкти "простими" або "чистим словниковим" об'єктом, тому що вони навіть простіше ніж звичайні об'єкти `{...}`.
 
-Недоліком є те, що такі об’єкти не мають вбудовані методи для роботи з ними, наприклад `toString`:
+Недоліком є те, що такі об'єкти не мають вбудовані методи для роботи з ними, наприклад `toString`:
 
 ```js run
 *!*
@@ -189,7 +189,7 @@ alert(obj); // Помилка (відсутній метод toString)
 
 ...Але це зазвичай нормально для асоціативних масивів.
 
-Зверніть увагу, що більшість методів пов’язаних з об’єктом `Object.something(...)`, такі як `Object.keys(obj)` -- не розміщуються в прототипі, тому вони будуть працювати з такими об’єктами:
+Зверніть увагу, що більшість методів пов'язаних з об'єктом `Object.something(...)`, такі як `Object.keys(obj)` -- не розміщуються в прототипі, тому вони будуть працювати з такими об'єктами:
 
 
 ```js run
@@ -207,7 +207,7 @@ alert(Object.keys(chineseDictionary)); // hello,bye
     - літеральний синтаксис: `{ __proto__: ... }`, дозволяє вказати кілька властивостей
     - або [Object.create(proto, [descriptors])](mdn:js/Object/create), дозволяє вказати дескриптори властивостей.
 
-    `Object.create` забезпечує простий спосіб поверхневого копіювання об’єкта з усіма дескрипторами:
+    `Object.create` забезпечує простий спосіб поверхневого копіювання об'єкта з усіма дескрипторами:
 
     ```js
     let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
@@ -220,8 +220,8 @@ alert(Object.keys(chineseDictionary)); // hello,bye
 
 - Отримання/встановлення прототипу за допомогою вбудованого `__proto__` геттера/сеттера не рекомендується, тепер це в Annex B специфікації.
 
-- Ми також розглядали об’єкти без прототипів, створені за допомогою `Object.create(null)` або `{__proto__: null}`.
+- Ми також розглядали об'єкти без прототипів, створені за допомогою `Object.create(null)` або `{__proto__: null}`.
 
-    Ці об’єкти використовуються як сховища ключ-значення для зберігання будь-яких (можливо, створених користувачем) ключів.
+    Ці об'єкти використовуються як сховища ключ-значення для зберігання будь-яких (можливо, створених користувачем) ключів.
 
-    Зазвичай об’єкти успадковують вбудовані методи та `__proto__` геттер/сеттер від `Object.prototype`, роблячи відповідні ключі "зайнятими", і це потенційно викликає побічні ефекти. З прототипом `null` об'єкти справді порожні.
+    Зазвичай об'єкти успадковують вбудовані методи та `__proto__` геттер/сеттер від `Object.prototype`, роблячи відповідні ключі "зайнятими", і це потенційно викликає побічні ефекти. З прототипом `null` об'єкти справді порожні.
diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
index 3caf54e72..f746be874 100644
--- a/1-js/09-classes/01-class/article.md
+++ b/1-js/09-classes/01-class/article.md
@@ -2,14 +2,14 @@
 # Базовий синтаксис класу
 
 ```quote author="Вікіпедія"
-В об’єктно-орієнтованому програмуванні, *клас* -- це спеціальна конструкція, яка використовується для групування пов’язаних змінних та функцій. При цьому, згідно з термінологією ООП, глобальні змінні класу (члени-змінні) називаються полями даних (також властивостями або атрибутами), а члени-функції називають методами класу.
+В об'єктно-орієнтованому програмуванні, *клас* -- це спеціальна конструкція, яка використовується для групування пов'язаних змінних та функцій. При цьому, згідно з термінологією ООП, глобальні змінні класу (члени-змінні) називаються полями даних (також властивостями або атрибутами), а члени-функції називають методами класу.
 ```
 
-На практиці ми часто повинні створювати багато об’єктів одного й того ж виду, наприклад користувачів, або товари чи що завгодно.
+На практиці ми часто повинні створювати багато об'єктів одного й того ж виду, наприклад користувачів, або товари чи що завгодно.
 
 Як ми вже знаємо з розділу <info:constructor-new>, `new function` може допомогти з цим.
 
-Але в сучасному JavaScript існує більш просунута конструкція "клас", яка вводить нові чудові функції, які корисні для об’єктно-орієнтованого програмування.
+Але в сучасному JavaScript існує більш просунута конструкція "клас", яка вводить нові чудові функції, які корисні для об'єктно-орієнтованого програмування.
 
 ## Синтаксис "class"
 
@@ -25,9 +25,9 @@ class MyClass {
 }
 ```
 
-Потім використовуйте `new MyClass()`, щоб створити новий об’єкт з усіма перерахованими методами.
+Потім використовуйте `new MyClass()`, щоб створити новий об'єкт з усіма перерахованими методами.
 
-Метод `constructor()` викликається автоматично за допомогою `new`, в ньому ми можемо ініціалізувати об’єкт.
+Метод `constructor()` викликається автоматично за допомогою `new`, в ньому ми можемо ініціалізувати об'єкт.
 
 Наприклад:
 
@@ -50,16 +50,16 @@ user.sayHi();
 ```
 
 Коли `new User("Іван")` викликається:
-1. Створюється новий об’єкт.
+1. Створюється новий об'єкт.
 2. `constructor` запускається з даним аргументом і присвоює його в `this.name`.
 
-...Потім ми можемо викликати методи об’єкту, такі як `user.sayHi()`.
+...Потім ми можемо викликати методи об'єкту, такі як `user.sayHi()`.
 
 
 ```warn header="Кома між методами класу не потрібна"
 Часта помилка розробників-початківців полягає в тому, що ставляться коми між методами класу, що призводить до синтаксичної помилки.
 
-Синтаксис класів не слід плутати з літералами об’єктів. У межах класу не треба ставити кому.
+Синтаксис класів не слід плутати з літералами об'єктів. У межах класу не треба ставити кому.
 ```
 
 ## Що таке клас?
@@ -89,7 +89,7 @@ alert(typeof User); // function
 1. Створює функцію, що називається `User` та стає результатом оголошення класу. Код цієї функції береться з методу `constructor` (вважається порожнім, якщо ми не написали такий метод).
 2. Записує методи класу, такі як `sayHi`, до `User.prototype`.
 
-Після того, як `new User` створився, коли ми викликаємо його метод, він береться з прототипу, як описано в розділі <info:function-prototype>. Таким чином, об’єкт має доступ до методів класу.
+Після того, як `new User` створився, коли ми викликаємо його метод, він береться з прототипу, як описано в розділі <info:function-prototype>. Таким чином, об'єкт має доступ до методів класу.
 
 Ми можемо проілюструвати результат оголошення `class User` наступним чином:
 
@@ -171,7 +171,7 @@ user.sayHi();
 2. Методи класу неперелічувані.
     Оголошення класу встановлює прапор `enumerable` у `false` для всіх методів в `"prototype"`.
 
-    Це добре тому, що коли ми перебираємо об’єкт за допомогою `for..in`, ми зазвичай не хочемо обробляти методи класу.
+    Це добре тому, що коли ми перебираємо об'єкт за допомогою `for..in`, ми зазвичай не хочемо обробляти методи класу.
 
 3. Клас завжди `use strict`.
     Весь код всередині конструкції класу автоматично знаходиться в суворому режимі.
@@ -231,7 +231,7 @@ new User().sayHi(); // Привіт
 
 ## Геттери/сеттери
 
-Подібно до літералів об’єктів, класи можуть включати геттери/сеттери, обчислені атрибути тощо.
+Подібно до літералів об'єктів, класи можуть включати геттери/сеттери, обчислені атрибути тощо.
 
 Ось приклад для `user.name`, що реалізований за допомогою `get/set`:
 
@@ -253,7 +253,7 @@ class User {
   set name(value) {
 */!*
     if (value.length < 4) {
-      alert("Ім’я занадто коротке.");
+      alert("Ім'я занадто коротке.");
       return;
     }
     this._name = value;
@@ -264,7 +264,7 @@ class User {
 let user = new User("Іван");
 alert(user.name); // Іван
 
-user = new User(""); // Ім’я занадто коротке.
+user = new User(""); // Ім'я занадто коротке.
 ```
 
 Технічно, таке оголошення класу працює шляхом створення геттерів та сеттерів в `User.prototype`.
@@ -287,7 +287,7 @@ class User {
 new User().sayHi();
 ```
 
-Такі особливості легко запам’ятати, оскільки вони нагадують літерали об’єктів.
+Такі особливості легко запам'ятати, оскільки вони нагадують літерали об'єктів.
 
 ## Поля класу
 
@@ -317,7 +317,7 @@ new User().sayHi(); // Привіт, Іван!
 
 Отже, ми просто пишемо `<property name> = <value>` в оголошенні, і все.
 
-Важливою відмінністю полів класу є те, що вони задаються в окремих об’єктах, а не в `User.prototype`:
+Важливою відмінністю полів класу є те, що вони задаються в окремих об'єктах, а не в `User.prototype`:
 
 ```js run
 class User {
@@ -336,7 +336,7 @@ alert(User.prototype.name); // undefined
 ```js run
 class User {
 *!*
-  name = prompt("Ім’я, будь ласка?", "Іван");
+  name = prompt("Ім'я, будь ласка?", "Іван");
 */!*
 }
 
@@ -345,11 +345,11 @@ alert(user.name); // Іван
 ```
 
 
-### Створення методів, що пов’язані з полями класу
+### Створення методів, що пов'язані з полями класу
 
 Як показано в розділі <info:bind>, функції в JavaScript мають динамічний `this`. Він залежить від контексту виклику.
 
-Отже, якщо метод об’єкта передається і викликається в іншому контексті, `this` більше не буде посиланням на цей об’єкт.
+Отже, якщо метод об'єкта передається і викликається в іншому контексті, `this` більше не буде посиланням на цей об'єкт.
 
 Наприклад, цей код покаже `undefined`:
 
@@ -376,7 +376,7 @@ setTimeout(button.click, 1000); // undefined
 Існує два підходи до розв'язання цієї проблеми, як обговорювалося в розділі <info:bind>:
 
 1. Передати функцію-обгортку, наприклад `setTimeout(() => button.click(), 1000)`.
-2. Зв’язати метод з об’єктом за допомогою функції `bind`, наприклад у конструкторі.
+2. Зв'язати метод з об'єктом за допомогою функції `bind`, наприклад у конструкторі.
 
 Поля класу надають інший, досить елегантний синтаксис:
 
@@ -397,7 +397,7 @@ let button = new Button("привіт");
 setTimeout(button.click, 1000); // привіт
 ```
 
-Поле класу `click = () => {...}` створюється на основі конкретного об’єкта, існує окрема функція для кожного об’єкта `Button`, з `this` всередині неї, що посилається на цей об’єкт. Ми можемо передати кнопку куди завгодно, а значення `this` завжди буде коректним.
+Поле класу `click = () => {...}` створюється на основі конкретного об'єкта, існує окрема функція для кожного об'єкта `Button`, з `this` всередині неї, що посилається на цей об'єкт. Ми можемо передати кнопку куди завгодно, а значення `this` завжди буде коректним.
 
 Це особливо корисно в середовищі браузера, для слухачів подій.
 
@@ -418,7 +418,7 @@ class MyClass {
   get something(...) {} // геттер метод
   set something(...) {} // сеттер метод
 
-  [Symbol.iterator]() {} // метод з обчисленим ім’ям (символом в цьому випадку)
+  [Symbol.iterator]() {} // метод з обчисленим ім'ям (символом в цьому випадку)
   // ...
 }
 ```
diff --git a/1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md b/1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md
index 1f836f86f..968b9f7d1 100644
--- a/1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md
+++ b/1-js/09-classes/02-class-inheritance/1-class-constructor-error/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Ось код з `Rabbit` розширює `Animal`.
 
-На жаль, неможливо створити об’єкти `Rabbit`. Що не так? Полагодьте це.
+На жаль, неможливо створити об'єкти `Rabbit`. Що не так? Полагодьте це.
 ```js run
 class Animal {
 
diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md
index 8c6f04f5a..69a7ee348 100644
--- a/1-js/09-classes/02-class-inheritance/article.md
+++ b/1-js/09-classes/02-class-inheritance/article.md
@@ -28,7 +28,7 @@ class Animal {
 let animal = new Animal("Моя тварина");
 ```
 
-Ось так можна графічно відобразити об’єкт `animal` і клас `Animal`:
+Ось так можна графічно відобразити об'єкт `animal` і клас `Animal`:
 
 ![](rabbit-animal-independent-animal.svg)
 
@@ -55,18 +55,18 @@ rabbit.run(5); // Білий Кролик біжить зі швидкістю 5
 rabbit.hide(); // Білий Кролик ховається!
 ```
 
-Об’єкт класу `Rabbit` має доступ і до методів `Rabbit`, таких як `rabbit.hide()`, і до методів `Animal`.
+Об'єкт класу `Rabbit` має доступ і до методів `Rabbit`, таких як `rabbit.hide()`, і до методів `Animal`.
 
 Внутрішньо, ключове слово `extends` працює за допомогою старої-доброї механіки прототипу. Він встановлює в `Rabbit.prototype.[[Prototype]]` значення `Animal.prototype`. Тому, якщо метод не знайдено в `Rabbit.prototype`, JavaScript бере його з `Animal.prototype`.
 
 ![](animal-rabbit-extends.svg)
 
 Наприклад, для пошуку методу `rabbit.run`, рушій перевіряє (знизу вгору на рисунку):
-1. Об’єкт `rabbit` (не має методу `run`).
+1. Об'єкт `rabbit` (не має методу `run`).
 2. Прототип `Rabbit`, тобто `Rabbit.prototype` (має `hide`, але не має `run`).
 3. Прототип `Animal`, тобто `Animal.prototype` (завдяки `extends`), який, нарешті, має метод `run`.
 
-Як ми можемо згадати з розділу <info:native-prototypes>, сам JavaScript використовує прототипне наслідування для вбудованих об’єктів. Наприклад, `Date.prototype.[[Prototype]]` -- це `Object.prototype`. Ось чому дати мають доступ до загальних методів об’єкта.
+Як ми можемо згадати з розділу <info:native-prototypes>, сам JavaScript використовує прототипне наслідування для вбудованих об'єктів. Наприклад, `Date.prototype.[[Prototype]]` -- це `Object.prototype`. Ось чому дати мають доступ до загальних методів об'єкта.
 
 ````smart header="Після слова `extends` допускається будь-який вираз"
 Синтаксис класу дозволяє вказати не лише клас, але будь-який вираз після `extends`.
@@ -444,7 +444,7 @@ let rabbit = {
 let longEar = {
   __proto__: rabbit,
   eat() {
-    // ...зробимо щось, що пов’язане з довгими вухами, і викликаємо батьківський (rabbit) метод
+    // ...зробимо щось, що пов'язане з довгими вухами, і викликаємо батьківський (rabbit) метод
     this.__proto__.eat.call(this); // (**)
   }
 };
diff --git a/1-js/09-classes/03-static-properties-methods/3-class-extend-object/task.md b/1-js/09-classes/03-static-properties-methods/3-class-extend-object/task.md
index e777f7dde..db653a756 100644
--- a/1-js/09-classes/03-static-properties-methods/3-class-extend-object/task.md
+++ b/1-js/09-classes/03-static-properties-methods/3-class-extend-object/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Клас розширює об’єкт?
+# Клас розширює об'єкт?
 
-Як ми знаємо, всі об’єкти зазвичай успадковуються від `Object.prototype` й отримують доступ до «загальних» методів об’єкта, наприклад `hasOwnProperty` тощо.
+Як ми знаємо, всі об'єкти зазвичай успадковуються від `Object.prototype` й отримують доступ до «загальних» методів об'єкта, наприклад `hasOwnProperty` тощо.
 
 Наприклад:
 
diff --git a/1-js/09-classes/03-static-properties-methods/article.md b/1-js/09-classes/03-static-properties-methods/article.md
index 000d6876f..5f23d4d46 100644
--- a/1-js/09-classes/03-static-properties-methods/article.md
+++ b/1-js/09-classes/03-static-properties-methods/article.md
@@ -29,11 +29,11 @@ User.staticMethod = function() {
 User.staticMethod(); // true
 ```
 
-Значенням `this` при виклику `User.staticMethod()` є сам конструктор класу `User` (правило «об’єкт перед крапкою»).
+Значенням `this` при виклику `User.staticMethod()` є сам конструктор класу `User` (правило «об'єкт перед крапкою»).
 
-Зазвичай статичні методи використовуються для реалізації функцій, які належать до класу, але не до будь-якого окремого його об’єкта.
+Зазвичай статичні методи використовуються для реалізації функцій, які належать до класу, але не до будь-якого окремого його об'єкта.
 
-Наприклад, у нас є об’єкти статей `Article` і необхідна функція для їх порівняння. 
+Наприклад, у нас є об'єкти статей `Article` і необхідна функція для їх порівняння. 
 
 Очевидне рішення -- додати метод `Article.compare`, наприклад:
 
@@ -88,7 +88,7 @@ class Article {
 
 *!*
   static createTodays() {
-    // пам’ятайте, this = Article
+    // пам'ятайте, this = Article
     return new this("Сьогоднішній дайджест", new Date());
   }
 */!*
@@ -101,7 +101,7 @@ alert( article.title ); // Сьогоднішній дайджест
 
 Тепер щоразу, коли нам потрібно створити сьогоднішній дайджест, ми можемо викликати `Article.createToday()`. Знову ж таки, це не метод конкретної статті, а метод цілого класу.
 
-Статичні методи також використовуються в класах, що пов’язані з базою даних, для пошуку/збереження/видалення записів із бази даних, наприклад:
+Статичні методи також використовуються в класах, що пов'язані з базою даних, для пошуку/збереження/видалення записів із бази даних, наприклад:
 
 ```js
 // припустимо, що Article -- це спеціальний клас для керування статтями
@@ -109,8 +109,8 @@ alert( article.title ); // Сьогоднішній дайджест
 Article.remove({id: 12345});
 ```
 
-````warn header="Статичні методи недоступні для окремих об’єктів"
-Статичні методи викликаються для класів, а не для окремих об’єктів.
+````warn header="Статичні методи недоступні для окремих об'єктів"
+Статичні методи викликаються для класів, а не для окремих об'єктів.
 
 Наприклад такий код не працюватиме:
 
diff --git a/1-js/09-classes/04-private-protected-properties-methods/article.md b/1-js/09-classes/04-private-protected-properties-methods/article.md
index 50089a437..a7e4fdfbc 100644
--- a/1-js/09-classes/04-private-protected-properties-methods/article.md
+++ b/1-js/09-classes/04-private-protected-properties-methods/article.md
@@ -1,9 +1,9 @@
 
 # Приватні та захищені властивості та методи
 
-Один з найважливіших принципів об’єктно-орієнтованого програмування -- розділення внутрішнього інтерфейсу від зовнішнього.
+Один з найважливіших принципів об'єктно-орієнтованого програмування -- розділення внутрішнього інтерфейсу від зовнішнього.
 
-Це обов’язкова практика у розробці вcього, що складніше, ніж застосунок "hello world".
+Це обов'язкова практика у розробці вcього, що складніше, ніж застосунок "hello world".
 
 Щоб зрозуміти це, відійдімо від розробки та поглянемо на реальний світ.
 
@@ -27,28 +27,28 @@
 
 Якщо ми видалимо захисне покриття з кавоварки, то використовувати її буде набагато складніше (де натискати?), і небезпечніше (вона може вдарити електричним струмом).
 
-Як ми побачимо, об’єкти у програмуванні подібні до кавоварок.
+Як ми побачимо, об'єкти у програмуванні подібні до кавоварок.
 
 Але для того, щоб приховати внутрішні деталі, ми будемо використовувати не захисну кришку, а особливий синтаксис мови та конвенції.
 
 ## Внутрішній та зовнішній інтерфейс
 
-У об’єктно-орієнтованому програмуванні, властивості та методи розділені на дві групи:
+У об'єктно-орієнтованому програмуванні, властивості та методи розділені на дві групи:
 
 - *Внутрішній інтерфейс* -- методи та властивості, доступні в інших методах класу, але не ззовні.
 - *Зовнішній інтерфейс* -- методи та властивості, доступні також ззовні класу.
 
-Якщо ми продовжимо аналогію з кавоваркою -- те, що приховано всередині: трубка кип’ятильника, нагрівальний елемент і так далі -- це його внутрішній інтерфейс.
+Якщо ми продовжимо аналогію з кавоваркою -- те, що приховано всередині: трубка кип'ятильника, нагрівальний елемент і так далі -- це його внутрішній інтерфейс.
 
-Внутрішній інтерфейс використовується об’єктом для роботи, його деталі використовують один одного. Наприклад, до нагрівального елемента прикріплюється трубка кип’ятильника.
+Внутрішній інтерфейс використовується об'єктом для роботи, його деталі використовують один одного. Наприклад, до нагрівального елемента прикріплюється трубка кип'ятильника.
 
 Але ззовні кавоварка закрита захисним покриттям так, що ніхто не може добратися до її нутрощів. Деталі приховані та недоступні. Ми можемо використовувати її функціонал за допомогою зовнішнього інтерфейсу.
 
-Отже, все, що нам потрібно для використання об’єкту, -- це знати його зовнішній інтерфейс. Ми можемо повністю не знати, як він працює всередині, і це чудово.
+Отже, все, що нам потрібно для використання об'єкту, -- це знати його зовнішній інтерфейс. Ми можемо повністю не знати, як він працює всередині, і це чудово.
 
 Це було загальне введення.
 
-У JavaScript існує два типи полів об’єктів (властивостей та методів):
+У JavaScript існує два типи полів об'єктів (властивостей та методів):
 
 - Публічні: доступні з будь-якого місця. Вони складають зовнішній інтерфейс. Досі ми використовували лише публічні властивості та методи.
 - Приватні: доступний тільки зсередини класу. Вони для внутрішнього інтерфейсу.
@@ -274,7 +274,7 @@ class MegaCoffeeMachine extends CoffeeMachine {
 class User {
   ...
   sayHi() {
-    let fieldName = "ім’я";
+    let fieldName = "ім'я";
     alert(`Привіт, ${*!*this[fieldName]*/!*}`);
   }
 }
@@ -305,7 +305,7 @@ class User {
 
     Якщо ви розробник такого класу, це чудово знати, що приватні методи можуть бути безпечно перейменовані, а їх параметри можуть бути змінені та навіть видалені, оскільки зовнішній код від них не залежить.
 
-    Для користувачів, коли з’явиться нова версія, вона може бути повністю перероблена в середині, але версію все ще просто оновити, якщо зовнішній інтерфейс однаковий.
+    Для користувачів, коли з'явиться нова версія, вона може бути повністю перероблена в середині, але версію все ще просто оновити, якщо зовнішній інтерфейс однаковий.
 
 Прихована складність
 : Люди обожнюють, використовуючи речі, які є простими. Принаймні ззовні. Що всередині -- це вже інша річ.
diff --git a/1-js/09-classes/05-extend-natives/article.md b/1-js/09-classes/05-extend-natives/article.md
index 4c86f5c6c..85bca8fed 100644
--- a/1-js/09-classes/05-extend-natives/article.md
+++ b/1-js/09-classes/05-extend-natives/article.md
@@ -21,7 +21,7 @@ alert(filteredArr); // 10, 50
 alert(filteredArr.isEmpty()); // false
 ```
 
-Зверніть увагу на дуже цікаву річ. Вбудовані методи, такі як `filter`, `map` та інші, повертають нові об’єкти точно успадкованого типу `PowerArray`. Їхня внутрішня реалізація використовує для цього властивість об’єкта `constructor`.
+Зверніть увагу на дуже цікаву річ. Вбудовані методи, такі як `filter`, `map` та інші, повертають нові об'єкти точно успадкованого типу `PowerArray`. Їхня внутрішня реалізація використовує для цього властивість об'єкта `constructor`.
 
 У вищенаведеному прикладі,
 ```js
@@ -32,7 +32,7 @@ arr.constructor === PowerArray
 
 Щобільше, ми можемо налаштувати таку поведінку.
 
-Ми можемо додати до класу спеціальний статичний геттер `Symbol.species`. Якщо він існує, то повинен повернути конструктор, який JavaScript буде використовувати внутрішньо для створення нових об’єктів у `map`, `filter` тощо.
+Ми можемо додати до класу спеціальний статичний геттер `Symbol.species`. Якщо він існує, то повинен повернути конструктор, який JavaScript буде використовувати внутрішньо для створення нових об'єктів у `map`, `filter` тощо.
 
 Якщо ж ми хочемо, щоб вбудовані методи, такі як `map` або `filter`, повертали звичайні масиви, ми можемо повернути `Array` у `Symbol.species`, як тут:
 
@@ -70,7 +70,7 @@ alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
 
 ## Відсутність статичного спадкування вбудованих класів
 
-Вбудовані об’єкти мають власні статичні методи, наприклад `Object.keys`, `Array.isArray` тощо.
+Вбудовані об'єкти мають власні статичні методи, наприклад `Object.keys`, `Array.isArray` тощо.
 
 Як ми вже знаємо, вбудовані класи розширюють один одного. Наприклад, `Array` розширює `Object`.
 
@@ -84,6 +84,6 @@ alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
 
 ![](object-date-inheritance.svg)
 
-Як бачите, немає зв’язку між `Date` і `Object`. Вони незалежні, лише `Date.prototype` успадковується від `Object.prototype`.
+Як бачите, немає зв'язку між `Date` і `Object`. Вони незалежні, лише `Date.prototype` успадковується від `Object.prototype`.
 
-Це важлива відмінність успадкування між вбудованими об’єктами в порівнянні з тим, що ми отримуємо за допомогою `extends`.
+Це важлива відмінність успадкування між вбудованими об'єктами в порівнянні з тим, що ми отримуємо за допомогою `extends`.
diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md
index 725d79251..667194ec8 100644
--- a/1-js/09-classes/06-instanceof/article.md
+++ b/1-js/09-classes/06-instanceof/article.md
@@ -1,6 +1,6 @@
 # Перевірка класу: "instanceof"
 
-Оператор `instanceof` дозволяє перевірити, чи належить об’єкт до певного класу. Він також враховує наслідування.
+Оператор `instanceof` дозволяє перевірити, чи належить об'єкт до певного класу. Він також враховує наслідування.
 
 Така перевірка може знадобитися в багатьох випадках. Наприклад, його можна використати для створення *поліморфної* функції, яка обробляє аргументи по-різному залежно від їх типу.
 
@@ -19,7 +19,7 @@ obj instanceof Class
 class Rabbit {}
 let rabbit = new Rabbit();
 
-// Чи це об’єкт класу Rabbit?
+// Чи це об'єкт класу Rabbit?
 *!*
 alert( rabbit instanceof Rabbit ); // true
 */!*
@@ -107,7 +107,7 @@ alert( arr instanceof Object ); // true
 
 Цікаво, але сам класс `Class` не бере участі в перевірці! Має значення лише ланцюжок прототипів і `Class.prototype`.
 
-Це може призвести до дивних наслідків, коли властивість `prototype` було змінено після створення об’єкта.
+Це може призвести до дивних наслідків, коли властивість `prototype` було змінено після створення об'єкта.
 
 Як тут:
 
@@ -126,7 +126,7 @@ alert( rabbit instanceof Rabbit ); // false
 
 ## Бонус: Object.prototype.toString для визначення типу
 
-Ми вже знаємо, що прості об’єкти перетворюються на рядки як `[object Object]`:
+Ми вже знаємо, що прості об'єкти перетворюються на рядки як `[object Object]`:
 
 ```js run
 let obj = {};
@@ -139,7 +139,7 @@ alert(obj.toString()); // теж саме
 
 Звучить дивно? Дійсно. Давайте розбиратися.
 
-У [специфікації](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), вбудований метод `toString` можна витягнути з об’єкта та викликати в контексті будь-якого іншого значення. І результат залежить від типу цього значення.
+У [специфікації](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), вбудований метод `toString` можна витягнути з об'єкта та викликати в контексті будь-якого іншого значення. І результат залежить від типу цього значення.
 
 - Для числа це буде `[object Number]`
 - Для логічного значення це буде `[object Boolean]`
@@ -174,7 +174,7 @@ alert( s.call(alert) ); // [object Function]
 
 ### Symbol.toStringTag
 
-Поведінку методу об’єкта `toString` можна налаштувати за допомогою спеціальної властивості `Symbol.toStringTag`.
+Поведінку методу об'єкта `toString` можна налаштувати за допомогою спеціальної властивості `Symbol.toStringTag`.
 
 Наприклад:
 
@@ -186,10 +186,10 @@ let user = {
 alert( {}.toString.call(user) ); // [object User]
 ```
 
-Для більшості специфічних для середовища об’єктів така властивість є. Ось деякі приклади для браузера:
+Для більшості специфічних для середовища об'єктів така властивість є. Ось деякі приклади для браузера:
 
 ```js run
-// toStringTag для специфічних для середовища об’єкту та класу:
+// toStringTag для специфічних для середовища об'єкту та класу:
 alert( window[Symbol.toStringTag]); // Window
 alert( XMLHttpRequest.prototype[Symbol.toStringTag] ); // XMLHttpRequest
 
@@ -199,9 +199,9 @@ alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest]
 
 Як бачите, результатом є саме `Symbol.toStringTag` (якщо існує), загорнутий у `[object ...]`.
 
-Наприкінці ми маємо "typeof на стероїдах", який працює не тільки для примітивних типів даних, але й для вбудованих об’єктів і навіть може бути кастомізований.
+Наприкінці ми маємо "typeof на стероїдах", який працює не тільки для примітивних типів даних, але й для вбудованих об'єктів і навіть може бути кастомізований.
 
-Ми можемо використати `{}.toString.call` замість `instanceof` для вбудованих об’єктів, коли ми хочемо отримати тип у вигляді рядка, а не просто для перевірки.
+Ми можемо використати `{}.toString.call` замість `instanceof` для вбудованих об'єктів, коли ми хочемо отримати тип у вигляді рядка, а не просто для перевірки.
 
 ## Підсумки
 
@@ -210,8 +210,8 @@ alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest]
 |               | працює для   |  повертає      |
 |---------------|-------------|---------------|
 | `typeof`      | примітивів  |  рядок       |
-| `{}.toString` | примітивів, вбудованих об’єктів, об’єктів з `Symbol.toStringTag`   |       рядок |
-| `instanceof`  | об’єктів     |  true/false   |
+| `{}.toString` | примітивів, вбудованих об'єктів, об'єктів з `Symbol.toStringTag`   |       рядок |
+| `instanceof`  | об'єктів     |  true/false   |
 
 Як ми бачимо, `{}.toString` технічно є "більш просунутим" `typeof`.
 
diff --git a/1-js/09-classes/07-mixins/article.md b/1-js/09-classes/07-mixins/article.md
index 8d77dede0..689b55e7a 100644
--- a/1-js/09-classes/07-mixins/article.md
+++ b/1-js/09-classes/07-mixins/article.md
@@ -1,6 +1,6 @@
 # Міксини
 
-В JavaScript ми можемо успадкуватися лише від одного об’єкта. Може бути лише один `[[Prototype]]` для об’єкта. І клас може розширювати лише один інший клас.
+В JavaScript ми можемо успадкуватися лише від одного об'єкта. Може бути лише один `[[Prototype]]` для об'єкта. І клас може розширювати лише один інший клас.
 
 Але іноді це викликає обмеження. Наприклад, у нас є клас `StreetSweeper` і клас `Bicycle`, і ми хочемо зробити їхню суміш: `StreetSweepingBicycle`.
 
@@ -14,7 +14,7 @@
 
 ## Приклад міксину
 
-Найпростіший спосіб реалізації міксинів в JavaScript є створення об’єкта з корисними методами, щоб ми могли легко об’єднати їх у прототип будь-якого класу.
+Найпростіший спосіб реалізації міксинів в JavaScript є створення об'єкта з корисними методами, щоб ми могли легко об'єднати їх у прототип будь-якого класу.
 
 Наприклад, тут використовується міксин `sayHiMixin`, щоб додати можливість "говорити" для класу `User`:
 
@@ -109,15 +109,15 @@ new User("Іван").sayHi(); // Привіт, Іван!
 
 Тепер зробімо міксин для реального життя.
 
-Важливою особливістю багатьох об’єктів браузера (для прикладу) є те, що вони можуть створювати події. Події -- це чудовий спосіб "транслювати інформацію" будь-кому, хто хоче її приймати. Отже, зробімо міксин, який дозволяє нам легко додавати функції, що пов’язані з подіями для будь-якого класу/об’єкта.
+Важливою особливістю багатьох об'єктів браузера (для прикладу) є те, що вони можуть створювати події. Події -- це чудовий спосіб "транслювати інформацію" будь-кому, хто хоче її приймати. Отже, зробімо міксин, який дозволяє нам легко додавати функції, що пов'язані з подіями для будь-якого класу/об'єкта.
 
 - Міксин забезпечить метод `.trigger(name, [...data])`, щоб "генерувати подію", коли щось відбувається з ним. Аргумент `name` -- це назва події, за бажанням можуть передаватися додаткові аргументи з даними про подію.
-- Також метод `.on(name, handler)`, що додає функцію `handler` як слухача до подій з даною назвою. Вона буде викликатися, коли подія з даним «ім’ям», і отримати аргументи з дзвінка `.trigger`.
+- Також метод `.on(name, handler)`, що додає функцію `handler` як слухача до подій з даною назвою. Вона буде викликатися, коли подія з даним «ім'ям», і отримати аргументи з дзвінка `.trigger`.
 - ...і метод `.off(name, handler)`, що видаляє слухач `handler`.
 
-Після додавання міксину, об’єкт `user` зможе генерувати подію `"login"`, коли відвідувач входить у систему. А інший об’єкт, скажімо, `calendar`, можливо захоче слухати такі події, щоб завантажити календар для зареєстрованої людини.
+Після додавання міксину, об'єкт `user` зможе генерувати подію `"login"`, коли відвідувач входить у систему. А інший об'єкт, скажімо, `calendar`, можливо захоче слухати такі події, щоб завантажити календар для зареєстрованої людини.
 
-Або `menu` може генерувати подію `"select"`, коли вибрано пункт меню, а інші об’єкти можуть призначати обробники, щоб реагувати на цю подію. І так далі.
+Або `menu` може генерувати подію `"select"`, коли вибрано пункт меню, а інші об'єкти можуть призначати обробники, щоб реагувати на цю подію. І так далі.
 
 Ось код:
 
@@ -178,7 +178,7 @@ class Menu {
     this.trigger("select", value);
   }
 }
-// Додамо міксин з методами, що пов’язані з подіями
+// Додамо міксин з методами, що пов'язані з подіями
 Object.assign(Menu.prototype, eventMixin);
 
 let menu = new Menu();
@@ -199,7 +199,7 @@ menu.choose("123");
 
 ## Висновки
 
-*Міксин* -- це загальний термін об’єктноорієнтованого програмування: клас, який містить методи для інших класів.
+*Міксин* -- це загальний термін об'єктноорієнтованого програмування: клас, який містить методи для інших класів.
 
 Деякі інші мови дозволяють багаторазове наслідування. JavaScript його не підтримує, але міксини можуть бути реалізовані шляхом копіювання методів у прототип.
 
diff --git a/1-js/10-error-handling/1-try-catch/article.md b/1-js/10-error-handling/1-try-catch/article.md
index 8317858eb..254d7f726 100644
--- a/1-js/10-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -26,7 +26,7 @@ try {
 
 1. В першу чергу виконується код в блоці `try {...}`.
 2. Якщо не виникає помилок, то блок `catch (err)` ігнорується: виконання досягає кінця блоку `try` та продовжується поза блоком `catch`.
-3. Якщо виникає помилка, тоді виконання в `try` припиняється і виконання коду продовжується з початку блоку `catch (err)`. Змінна `err` (можна обрати будь-яке ім’я) буде містити об’єкт помилки з додатковою інформацією.
+3. Якщо виникає помилка, тоді виконання в `try` припиняється і виконання коду продовжується з початку блоку `catch (err)`. Змінна `err` (можна обрати будь-яке ім'я) буде містити об'єкт помилки з додатковою інформацією.
 
 ![](try-catch-flow.svg)
 
@@ -118,19 +118,19 @@ setTimeout(function() {
 ```
 ````
 
-## Об’єкт помилки
+## Об'єкт помилки
 
-Коли виникає помилка, JavaScript генерує об’єкт, що містить інформацію про неї. Потім цей об’єкт передається як аргумент в `catch`:
+Коли виникає помилка, JavaScript генерує об'єкт, що містить інформацію про неї. Потім цей об'єкт передається як аргумент в `catch`:
 
 ```js
 try {
   // ...
-} catch (err) { // <-- "об’єкт помилки", можна використати іншу назву замість err
+} catch (err) { // <-- "об'єкт помилки", можна використати іншу назву замість err
   // ...
 }
 ```
 
-Для всіх вбудованих помилок об’єкт помилки має дві головні властивості:
+Для всіх вбудованих помилок об'єкт помилки має дві головні властивості:
 
 `name`
 : Назва помилки. Наприклад, для невизначеної змінної назва буде `"ReferenceError"`.
@@ -165,7 +165,7 @@ try {
 
 [recent browser=new]
 
-Блок `catch` не обов’язково повинен перехоплювати інформацію про об’єкт помилки:
+Блок `catch` не обов'язково повинен перехоплювати інформацію про об'єкт помилки:
 
 ```js
 try {
@@ -189,10 +189,10 @@ try {
 let json = '{"name":"Іван", "age": 30}'; // дані з серверу
 
 *!*
-let user = JSON.parse(json); // трансформуємо текстове значення в JS об’єкт
+let user = JSON.parse(json); // трансформуємо текстове значення в JS об'єкт
 */!*
 
-// тепер user це об’єкт, що містить властивості з рядку
+// тепер user це об'єкт, що містить властивості з рядку
 alert( user.name ); // Іван
 alert( user.age );  // 30
 ```
@@ -252,7 +252,7 @@ try {
 
 В такому разі `JSON.parse` відпрацює без виключень, але відсутність поля `name` є помилкою з нашої точки зору.
 
-Ми будемо використовувати оператор `throw` для об’єднання способів обробки помилок.
+Ми будемо використовувати оператор `throw` для об'єднання способів обробки помилок.
 
 ### Оператор "throw"
 
@@ -261,12 +261,12 @@ try {
 Оператор має синтаксис:
 
 ```js
-throw <об’єкт помилки>
+throw <об'єкт помилки>
 ```
 
-Рушії дозволяє використовувати будь-які значення як об’єкти помилки. Це може бути навіть примітивне значення, як число чи рядок, але краще використовувати об’єкти, що мають властивості `name` та `message` (для сумісності з вбудованим типом помилок).
+Рушії дозволяє використовувати будь-які значення як об'єкти помилки. Це може бути навіть примітивне значення, як число чи рядок, але краще використовувати об'єкти, що мають властивості `name` та `message` (для сумісності з вбудованим типом помилок).
 
-JavaScript має багато вбудованих конструкторів для вбудованих помилок: `Error`, `SyntaxError`, `ReferenceError`, `TypeError` та інші. Також вони можуть бути використаними для створення об’єктів помилок.
+JavaScript має багато вбудованих конструкторів для вбудованих помилок: `Error`, `SyntaxError`, `ReferenceError`, `TypeError` та інші. Також вони можуть бути використаними для створення об'єктів помилок.
 
 Синтаксис ініціалізації вбудованих помилок:
 
@@ -347,7 +347,7 @@ try {
   // ...
 } catch (err) {
   alert("JSON Error: " + err); // JSON Error: ReferenceError: user is not defined
-  // (але перехоплена помилка не пов’язана з JSON Error)
+  // (але перехоплена помилка не пов'язана з JSON Error)
 }
 ```
 
@@ -362,7 +362,7 @@ try {
 Розгляньмо підхід "повторного викидання" покроково:
 
 1. Конструкція `catch` перехоплює всі помилки.
-2. В блоці `catch (err) {...}` ми аналізуємо об’єкт помилки `err`.
+2. В блоці `catch (err) {...}` ми аналізуємо об'єкт помилки `err`.
 3. Якщо ми не знаємо як правильно обробити помилку, ми робимо `throw err`.
 
 Зазвичай, тип помилки можна перевірити за допомогою оператора `instanceof`:
@@ -491,7 +491,7 @@ try {
 
 Блок `finally` використовується, якщо ми почали виконувати якусь роботу і хочемо завершити її в будь-якому разі.
 
-Наприклад, ми хочемо виміряти час роботи функції, що рахує числа Фібоначчі. Для цього ми можемо почати вимірювання на початку виконання і закінчити після. А якщо протягом роботи функції виникне помилка? Зокрема, імплементація `fib(n)` нижче генерує виключення, якщо на вхід подано від’ємне або неціле число.
+Наприклад, ми хочемо виміряти час роботи функції, що рахує числа Фібоначчі. Для цього ми можемо почати вимірювання на початку виконання і закінчити після. А якщо протягом роботи функції виникне помилка? Зокрема, імплементація `fib(n)` нижче генерує виключення, якщо на вхід подано від'ємне або неціле число.
 
 Конструкція `finally` відмінне місце для завершення вимірювання незалежно від результату.
 
@@ -504,7 +504,7 @@ let diff, result;
 
 function fib(n) {
   if (n < 0 || Math.trunc(n) != n) {
-    throw new Error("Число не повинно бути від’ємним або дробовим.");
+    throw new Error("Число не повинно бути від'ємним або дробовим.");
   }
   return n <= 1 ? n : fib(n - 1) + fib(n - 2);
 }
@@ -610,7 +610,7 @@ window.onerror = function(message, url, line, col, error) {
 : Номер рядку та колонки, де трапилась помилка.
 
 `error`
-: Об’єкт помилки.
+: Об'єкт помилки.
 
 Приклад:
 
@@ -660,15 +660,15 @@ try {
 
 Також ми можемо пропустити секцію `catch` чи `finally`, тому скорочені конструкції `try...catch` та `try...finally` теж валідні.
 
-Об’єкт помилки має наступні властивості:
+Об'єкт помилки має наступні властивості:
 
 - `message` -- розбірливе повідомлення про помилку.
 - `name` -- рядок з іменем помилки (назва конструктора помилки).
 - `stack` (нестандартна, але широко підтримувана) -- стек викликів на момент створення помилки.
 
-Ми можемо пропустити отримання об’єкту помилки, якщо використати `catch {` замість `catch (err) {`.
+Ми можемо пропустити отримання об'єкту помилки, якщо використати `catch {` замість `catch (err) {`.
 
-Також ми можемо генерувати власні помилки за допомогою оператору `throw`. Технічно, будь-що можна передати аргументом в `throw`, але, зазвичай, використовується об’єкт, успадкований від вбудованого класу `Error`. Детальніше про розширення помилок в наступному розділі.
+Також ми можемо генерувати власні помилки за допомогою оператору `throw`. Технічно, будь-що можна передати аргументом в `throw`, але, зазвичай, використовується об'єкт, успадкований від вбудованого класу `Error`. Детальніше про розширення помилок в наступному розділі.
 
 *Повторне викидання* -- важливий шаблон в роботі з помилками: переважно блок `catch` знає як обробляти помилки певного типу, тому він повинен знову викидати невідомі типи помилок.
 
diff --git a/1-js/10-error-handling/2-custom-errors/article.md b/1-js/10-error-handling/2-custom-errors/article.md
index 61526f905..1836eabfe 100644
--- a/1-js/10-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -2,9 +2,9 @@
 
 Коли ми щось розробляємо, нам часто потрібні власні класи помилок, щоб відображати конкретні речі, які можуть піти не так у наших програмах. Для помилок у мережевих операціях нам може знадобитися `HttpError`, для операцій з базою даних `DbError`, для пошуку операцій `NotFoundError` тощо.
 
-Наші помилки повинні підтримувати основні властивості помилок, такі як `message`, `name` і, бажано, `stack`. Але вони також можуть мати інші властивості, наприклад, об’єкти `HttpError` можуть мати властивість `statusCode` зі значенням, як-от `404`, `403` або `500`.
+Наші помилки повинні підтримувати основні властивості помилок, такі як `message`, `name` і, бажано, `stack`. Але вони також можуть мати інші властивості, наприклад, об'єкти `HttpError` можуть мати властивість `statusCode` зі значенням, як-от `404`, `403` або `500`.
 
-JavaScript дозволяє використовувати `throw` з будь-яким аргументом, тому технічно наші спеціальні класи помилок не повинні успадковуватись від `Error`. Але якщо ми успадкуємо, то стає можливим використовувати `obj instanceof Error` для ідентифікації об’єктів помилки. Тому краще успадкувати від нього.
+JavaScript дозволяє використовувати `throw` з будь-яким аргументом, тому технічно наші спеціальні класи помилок не повинні успадковуватись від `Error`. Але якщо ми успадкуємо, то стає можливим використовувати `obj instanceof Error` для ідентифікації об'єктів помилки. Тому краще успадкувати від нього.
 
 У міру розвитку програми наші власні помилки, природньо, утворюють ієрархію. Наприклад, `HttpTimeoutError` може успадковуватися від `HttpError` тощо.
 
@@ -19,7 +19,7 @@ let json = `{ "name": "Іван", "age": 30 }`;
 
 Всередині ми будемо використовувати `JSON.parse`. Якщо він отримує неправильний `json`, він викидає `SyntaxError`. Але навіть якщо `json` синтаксично правильний, це не означає, що це валідний користувач, чи не так? У ньому може не бути необхідних нам даних. Наприклад, він може не мати властивостей `name` та `age`, які є важливими для наших користувачів.
 
-Наша функція `readUser(json)` не тільки читатиме JSON, але й перевірятеме ("валідуватиме") дані. Якщо немає обов’язкових полів або формат неправильний, це помилка. І це не `SyntaxError`, оскільки дані синтаксично правильні, а інший тип помилки. Ми назвемо його `ValidationError` і створимо для нього окремий клас. Подібна помилка також повинна містити інформацію про поле, що порушує правила.
+Наша функція `readUser(json)` не тільки читатиме JSON, але й перевірятеме ("валідуватиме") дані. Якщо немає обов'язкових полів або формат неправильний, це помилка. І це не `SyntaxError`, оскільки дані синтаксично правильні, а інший тип помилки. Ми назвемо його `ValidationError` і створимо для нього окремий клас. Подібна помилка також повинна містити інформацію про поле, що порушує правила.
 
 Наш клас `ValidationError` має успадковуватись від класу `Error`.
 
@@ -61,7 +61,7 @@ try {
 }
 ```
 
-Зверніть увагу: у рядку `(1)` ми викликаємо батьківський конструктор. JavaScript вимагає від нас викликати `super` у дочірньому конструкторі, це обов’язково. Батьківський конструктор встановлює властивість `message`.
+Зверніть увагу: у рядку `(1)` ми викликаємо батьківський конструктор. JavaScript вимагає від нас викликати `super` у дочірньому конструкторі, це обов'язково. Батьківський конструктор встановлює властивість `message`.
 
 Батьківський конструктор також встановлює для властивості `name` значення `"Error"`, тому в рядку `(2)` ми скидаємо його до потрібного значення.
 
@@ -178,9 +178,9 @@ try {
 }
 ```
 
-Новий клас `PropertyRequiredError` простий у використанні: нам потрібно лише передати ім’я властивості: `new PropertyRequiredError(property)`. Повідомлення `message` у зрозумілому вигляді генерується його конструктором.
+Новий клас `PropertyRequiredError` простий у використанні: нам потрібно лише передати ім'я властивості: `new PropertyRequiredError(property)`. Повідомлення `message` у зрозумілому вигляді генерується його конструктором.
 
-Зверніть увагу, що `this.name` у конструкторі `PropertyRequiredError` знову призначається вручну. Це може набриднути -- призначати `this.name = <ім’я класу>` у кожному спеціальному класі помилок. Ми можемо уникнути цього, створивши наш власний клас "базова помилка", який призначає `this.name = this.constructor.name`. А потім успадковувати всі наші власні помилки від нього.
+Зверніть увагу, що `this.name` у конструкторі `PropertyRequiredError` знову призначається вручну. Це може набриднути -- призначати `this.name = <ім'я класу>` у кожному спеціальному класі помилок. Ми можемо уникнути цього, створивши наш власний клас "базова помилка", який призначає `this.name = this.constructor.name`. А потім успадковувати всі наші власні помилки від нього.
 
 Назвемо його `MyError`.
 
@@ -245,7 +245,7 @@ try {
 
 1. Ми створимо новий клас `ReadError`, щоб представляти загальну помилку "читання даних".
 2. Функція `readUser` буде ловити помилки читання даних, які виникають всередині неї, наприклад, `ValidationError` і `SyntaxError`, і натомість генеруватиме `ReadError`.
-3. Об’єкт `ReadError` зберігатиме посилання на вихідну помилку у своїй властивості `cause`.
+3. Об'єкт `ReadError` зберігатиме посилання на вихідну помилку у своїй властивості `cause`.
 
 Тоді код, який викликає `readUser`, повинен буде перевіряти лише `ReadError`, а не всі види помилок читання даних. І якщо йому потрібні додаткові відомості про помилку, він може перевірити її властивість `cause`.
 
@@ -321,10 +321,10 @@ try {
 
 Отже, зовнішній код перевіряє `instanceof ReadError` і все. Немає необхідності перевіряти всі можливі типи помилок.
 
-Цей підхід називається "обгортання винятків", тому що ми беремо винятки "низького рівня" і "загортаємо" їх у `ReadError`, що є більш абстрактним. Такий підхід широко використовується в об’єктно-орієнтованому програмуванні.
+Цей підхід називається "обгортання винятків", тому що ми беремо винятки "низького рівня" і "загортаємо" їх у `ReadError`, що є більш абстрактним. Такий підхід широко використовується в об'єктно-орієнтованому програмуванні.
 
 ## Підсумки
 
 - Зазвичай класи своїх помилок ми можемо успадковувати від `Error` та інших вбудованих класів. Нам просто потрібно подбати про властивість `name` і не забути викликати `super`.
-- Ми можемо використовувати `instanceof` для перевірки певних помилок. Це також працює зі спадковістю. Але іноді ми маємо об’єкт помилки, який надходить із бібліотеки від сторонніх розробників, і немає простого способу отримати його клас. Тоді для таких перевірок можна використовувати властивість `name`.
-- Обгортання винятків є широко поширеною технікою: функція обробляє винятки низького рівня і створює помилки вищого рівня замість різноманітних низькорівневих. Винятки низького рівня іноді стають властивостями цього об’єкта, наприклад, `err.cause`, як у наведених вище прикладах, але це не є суворо обов’язковим.
+- Ми можемо використовувати `instanceof` для перевірки певних помилок. Це також працює зі спадковістю. Але іноді ми маємо об'єкт помилки, який надходить із бібліотеки від сторонніх розробників, і немає простого способу отримати його клас. Тоді для таких перевірок можна використовувати властивість `name`.
+- Обгортання винятків є широко поширеною технікою: функція обробляє винятки низького рівня і створює помилки вищого рівня замість різноманітних низькорівневих. Винятки низького рівня іноді стають властивостями цього об'єкта, наприклад, `err.cause`, як у наведених вище прикладах, але це не є суворо обов'язковим.
diff --git a/1-js/11-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
index da8e9c9a3..71caaca3c 100644
--- a/1-js/11-async/02-promise-basics/article.md
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -10,7 +10,7 @@
 
 1. Є код–"виробник", котрий щось робить, що займає час. Наприклад, завантажує дані з мережі. Згідно з нашою аналогією це "співак".
 2. Є код–"споживач", котрий очікує отримати результат від коду-"виробника", як тільки той буде готовий. Цей результат може знадобитися багатьом функціям. Це -- "фанати"
-3. *Promise* (надалі будемо називати такий об’єкт промісом) -- це спеціальний об’єкт в JavaScript, котрий зв’язує код-"виробника" і "споживача" разом. В контексті нашої аналогії -- це "список підписки". Код-"виробник" виконується стільки часу, скільки потрібно щоб отримати результат, а проміс — як тільки результат готовий, робить його доступним для коду який підписався на конкретний проміс.
+3. *Promise* (надалі будемо називати такий об'єкт промісом) -- це спеціальний об'єкт в JavaScript, котрий зв'язує код-"виробника" і "споживача" разом. В контексті нашої аналогії -- це "список підписки". Код-"виробник" виконується стільки часу, скільки потрібно щоб отримати результат, а проміс — як тільки результат готовий, робить його доступним для коду який підписався на конкретний проміс.
 
 Аналогія не зовсім точна, оскільки реалізація промісів в JavaScript набагато складніша ніж простий список підписок: вони володіють додатковими можливостями і обмеженнями. Але для початку варто почати з простішого.
 
@@ -29,11 +29,11 @@ let promise = new Promise(function(resolve, reject) {
 Коли функція-виконавець завершить свою роботу, неважливо -- зараз чи пізніше, вона повинна викликати один з цих колбеків:
 
 - `resolve(value)` -- якщо код успішно виконався, з результатом `value`.
-- `reject(error)` -- якщо виникла помилка, `error` -- об’єкт помилки.
+- `reject(error)` -- якщо виникла помилка, `error` -- об'єкт помилки.
 
 Отже, виконавець запускається автоматично і намагається виконати роботу. А потім викликає метод `resolve` якщо спроба була успішною або `reject` якщо виникла помилка.
 
-В об’єкта `promise`, що повертається конструктором `new Promise` є внутрішні властивості:
+В об'єкта `promise`, що повертається конструктором `new Promise` є внутрішні властивості:
 
 - `state` (стан) — спочатку `"pending"` (очікування), в результаті виконання функції він може змінюватися на: `"fulfilled"` коли викликається метод `resolve` і на `"rejected"`  коли `reject`.
 - `result` (результат) — спочатку `undefined`, далі змінюється на `value` коли викликається метод `resolve(value)` або `error` коли `reject(error)`.
@@ -60,7 +60,7 @@ let promise = new Promise(function(resolve, reject) {
 1. Функція-виконавець викликається одразу ж при виклику `new Promise`.
 2. Виконавець отримує два аргументи: `resolve` і `reject` -- ці функції вбудовані в JavaScript, тому нам непотрібно їх створювати. Нам слід всього лиш викликати одну з них по готовності.
 
-    Через одну секунду "обробки" виконавець викличе `resolve("done")`, щоб передати результат. Ця дія змінить стан об’єкта `promise` (що повертається конструктором `new Promise`) з `"pending"` на `"fulfilled"`:
+    Через одну секунду "обробки" виконавець викличе `resolve("done")`, щоб передати результат. Ця дія змінить стан об'єкта `promise` (що повертається конструктором `new Promise`) з `"pending"` на `"fulfilled"`:
 
     ![](promise-resolve-1.svg)
 
@@ -75,11 +75,11 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-Виклик методу `reject(...)` переводить стан об’єкта `promise` в `"rejected"`:
+Виклик методу `reject(...)` переводить стан об'єкта `promise` в `"rejected"`:
 
 ![](promise-reject-1.svg)
 
-Підіб’ємо проміжні підсумки: функція-виконавець виконує задачу (щось, що як правило потребує часу), потім викликається один з методів `resolve` чи `reject`, в залежності від успішності виконання коду. Які своєю чергою змінюють стан об’єкта який повертає конструктор `new Promise`.
+Підіб'ємо проміжні підсумки: функція-виконавець виконує задачу (щось, що як правило потребує часу), потім викликається один з методів `resolve` чи `reject`, в залежності від успішності виконання коду. Які своєю чергою змінюють стан об'єкта який повертає конструктор `new Promise`.
 
 Проміс -- в стані `resolve` чи `reject` будемо називати "завершеним (settled)", на відміну від початкового стану проміса "в очікуванні (`pending`)".
 
@@ -104,12 +104,12 @@ let promise = new Promise(function(resolve, reject) {
 Зверніть увагу, що методи `resolve`/`reject` можуть прийняти тільки один аргумент (або жодного), а всі додаткові аргументи будуть проігноровані.
 ````
 
-```smart header="Викликайте `reject` з об’єктом `Error`"
-У випадку якщо щось пішло не так, функції-виконавцю слід викликати метод `reject`. В `reject` можна передати аргумент будь-якого типу (як і в `resolve`), але рекомендується використовувати об’єкт `Error` (чи успадкований від нього об’єкт). Чому так? Скоро вам стане зрозуміло.
+```smart header="Викликайте `reject` з об'єктом `Error`"
+У випадку якщо щось пішло не так, функції-виконавцю слід викликати метод `reject`. В `reject` можна передати аргумент будь-якого типу (як і в `resolve`), але рекомендується використовувати об'єкт `Error` (чи успадкований від нього об'єкт). Чому так? Скоро вам стане зрозуміло.
 ```
 
 ````smart header="Негайний виклик `resolve`/`reject`"
-На практиці функція-виконавець робить щось асинхронне і через якийсь час викликає `resolve`/`reject`. Проте це необов’язково. `resolve` чи `reject` можуть викликатись одразу:
+На практиці функція-виконавець робить щось асинхронне і через якийсь час викликає `resolve`/`reject`. Проте це необов'язково. `resolve` чи `reject` можуть викликатись одразу:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
@@ -124,12 +124,12 @@ let promise = new Promise(function(resolve, reject) {
 ````
 
 ```smart header="Властивості `state` і `result` -- внутрішні"
-Властивості `state` and `result` -- внутрішні властивості об’єкта `Promise`, тому ми не маємо до них прямого доступу. Для обробки результату слід використовувати методи: `.then`/`.catch`/`.finally`. Про них далі піде мова.
+Властивості `state` and `result` -- внутрішні властивості об'єкта `Promise`, тому ми не маємо до них прямого доступу. Для обробки результату слід використовувати методи: `.then`/`.catch`/`.finally`. Про них далі піде мова.
 ```
 
 ## Споживачі: then, catch
 
-Об’єкт `Promise` служить зв’язною ланкою між функцією виконавцем (код "виробник" чи "співак") і функціями-споживачами ("фанатами"), котрі отримають або результат, або помилку. Функції споживачі можуть зареєструватись (підписатись) за допомогою методів `.then` та `.catch`.
+Об'єкт `Promise` служить зв'язною ланкою між функцією виконавцем (код "виробник" чи "співак") і функціями-споживачами ("фанатами"), котрі отримають або результат, або помилку. Функції споживачі можуть зареєструватись (підписатись) за допомогою методів `.then` та `.catch`.
 
 ### then
 
@@ -267,7 +267,7 @@ new Promise((resolve, reject) => {
       throw new Error("помилка");
     })
       .finally(() => alert("Проміс завершений")) // запускається першим
-      .catch(err => alert(err));  // <-- .catch обробляє об’єкт помилки
+      .catch(err => alert(err));  // <-- .catch обробляє об'єкт помилки
     ```
 
 3. Обробник `finally` також не повинен нічого повертати. Якщо все ж таки він щось повертає, це значення ігнорується.
@@ -323,7 +323,7 @@ function loadScript(src, callback) {
 
 Тепер перепишемо її використавши проміс.
 
-Новій функції `loadScript` більше не потрібен колбек. Замість цього вона буде створювати і повертати об’єкт проміса, котрий перейде в стан "успішно завершений", коли завантаження завершиться. Зовнішній код також може додавати обробників ("підписників") використовуючи `.then`:
+Новій функції `loadScript` більше не потрібен колбек. Замість цього вона буде створювати і повертати об'єкт проміса, котрий перейде в стан "успішно завершений", коли завантаження завершиться. Зовнішній код також може додавати обробників ("підписників") використовуючи `.then`:
 
 ```js run
 function loadScript(src) {
diff --git a/1-js/11-async/03-promise-chaining/article.md b/1-js/11-async/03-promise-chaining/article.md
index 4952d1b20..2a46ba4e7 100644
--- a/1-js/11-async/03-promise-chaining/article.md
+++ b/1-js/11-async/03-promise-chaining/article.md
@@ -189,11 +189,11 @@ loadScript("/article/promise-chaining/one.js").then(script1 => {
 
 
 ````smart header="Thenables"
-Якщо бути точним, обробник може повернути не зовсім проміс, а так званий об’єкт "thenable" - довільний об’єкт, який має метод `.then`. Це буде розглядатися так само, як проміс.
+Якщо бути точним, обробник може повернути не зовсім проміс, а так званий об'єкт "thenable" - довільний об'єкт, який має метод `.then`. Це буде розглядатися так само, як проміс.
 
-Ідея полягає в тому, що сторонні бібліотеки можуть реалізовувати власні промісо-сумісні об’єкти. Вони можуть мати розширений набір методів, але також можуть бути сумісні з нативними промісами, оскільки вони реалізують `.then`.
+Ідея полягає в тому, що сторонні бібліотеки можуть реалізовувати власні промісо-сумісні об'єкти. Вони можуть мати розширений набір методів, але також можуть бути сумісні з нативними промісами, оскільки вони реалізують `.then`.
 
-Ось приклад такого об’єкта:
+Ось приклад такого об'єкта:
 
 ```js run
 class Thenable {
@@ -216,9 +216,9 @@ new Promise(resolve => resolve(1))
   .then(alert); // показує 2 через 1000 мс
 ```
 
-JavaScript перевіряє об’єкт, повернутий обробником `.then` у рядку `(*)`: якщо він має викликаний метод з ім’ям `then`, тоді він викликає цей метод, та надає власні функції `resolve`, `reject` як аргументи (подібно виконавцю) і чекає, поки один з них не буде викликаний. У наведеному вище прикладі `resolve(2)` викликається через 1 секунду `(**)`. Потім результат передається далі по ланцюжку.
+JavaScript перевіряє об'єкт, повернутий обробником `.then` у рядку `(*)`: якщо він має викликаний метод з ім'ям `then`, тоді він викликає цей метод, та надає власні функції `resolve`, `reject` як аргументи (подібно виконавцю) і чекає, поки один з них не буде викликаний. У наведеному вище прикладі `resolve(2)` викликається через 1 секунду `(**)`. Потім результат передається далі по ланцюжку.
 
-Ця функція дозволяє нам інтегрувати власні об’єкти з ланцюжками промісів без успадкування від `Promise`.
+Ця функція дозволяє нам інтегрувати власні об'єкти з ланцюжками промісів без успадкування від `Promise`.
 ````
 
 
@@ -232,7 +232,7 @@ JavaScript перевіряє об’єкт, повернутий обробни
 let promise = fetch(url);
 ```
 
-Зазначений код робить мережевий запит до `url` і повертає проміс. Проміс розв’язується за допомогою об’єкта `response`, коли віддалений сервер відповідає заголовками, але *до завантаження повної відповіді*.
+Зазначений код робить мережевий запит до `url` і повертає проміс. Проміс розв'язується за допомогою об'єкта `response`, коли віддалений сервер відповідає заголовками, але *до завантаження повної відповіді*.
 
 Щоб прочитати повну відповідь, ми повинні викликати метод `response.text()`: він повертає проміс, який виконується, коли повний текст завантажується з віддаленого сервера, і містить цей текст як результат.
 
@@ -252,7 +252,7 @@ fetch('/article/promise-chaining/user.json')
   });
 ```
 
-Об’єкт `response`, повернутий із `fetch`, також включає метод `response.json()`, який зчитує віддалені дані у форматі JSON. У нашому випадку це ще зручніше, тож перейдемо до нього.
+Об'єкт `response`, повернутий із `fetch`, також включає метод `response.json()`, який зчитує віддалені дані у форматі JSON. У нашому випадку це ще зручніше, тож перейдемо до нього.
 
 Ми також будемо використовувати стрілкові функції для стислості:
 
@@ -260,7 +260,7 @@ fetch('/article/promise-chaining/user.json')
 // те саме, що й вище, але response.json() зчитує віддалений контент у форматі JSON
 fetch('/article/promise-chaining/user.json')
   .then(response => response.json())
-  .then(user => alert(user.name)); // iliakan, отримали ім’я користувача
+  .then(user => alert(user.name)); // iliakan, отримали ім'я користувача
 ```
 
 Тепер давайте зробимо щось із завантаженим користувачем.
@@ -291,7 +291,7 @@ fetch('/article/promise-chaining/user.json')
 
 Подивіться на рядок `(*)`: як ми можемо щось зробити *після* того, як аватар закінчить відображатися і видалиться? Наприклад, ми хотіли б показати форму для редагування цього користувача чи щось інше. Поки що такої можливості немає.
 
-Щоб ланцюжок міг розширюватися, нам потрібно повернути проміс, який розв’язується, коли аватар закінчує відображатися.
+Щоб ланцюжок міг розширюватися, нам потрібно повернути проміс, який розв'язується, коли аватар закінчує відображатися.
 
 Ось так:
 
diff --git a/1-js/11-async/04-promise-error-handling/article.md b/1-js/11-async/04-promise-error-handling/article.md
index 0b3f0e1bf..f7786b6d9 100644
--- a/1-js/11-async/04-promise-error-handling/article.md
+++ b/1-js/11-async/04-promise-error-handling/article.md
@@ -13,7 +13,7 @@ fetch('https://no-such-server.blabla') // помилка
   .catch(err => alert(err)) // TypeError: failed to fetch (текст може відрізнятися)
 ```
 
-Як можна побачити, `.catch` не обов’язково повинен бути відразу після помилки, він може бути далі, після одного або навіть декількох `.then`.
+Як можна побачити, `.catch` не обов'язково повинен бути відразу після помилки, він може бути далі, після одного або навіть декількох `.then`.
 
 Або, можливо, з сервером все гаразд, але у відповіді ми отримуємо некоректний JSON. Найлегший шлях перехопити усі помилки - це додати `.catch` в кінець ланцюжка:
 
@@ -177,9 +177,9 @@ JavaScript-рушій відстежує такі ситуації і генер
 ```js run
 *!*
 window.addEventListener('unhandledrejection', function(event) {
-  // об’єкт події має дві спеціальні властивості:
+  // об'єкт події має дві спеціальні властивості:
   alert(event.promise); // [object Promise] - проміс, який згенерував помилку
-  alert(event.reason); // Error: Whoops! - об’єкт помилки, яка не була оброблена
+  alert(event.reason); // Error: Whoops! - об'єкт помилки, яка не була оброблена
 });
 */!*
 
@@ -190,7 +190,7 @@ new Promise(function() {
 
 Ця подія є частиною [стандарту HTML](https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections).
 
-Якщо відбувається помилка, і відсутній її обробник, то генерується подія `unhandledrejection`, і відповідний об’єкт `event` містить інформацію про помилку.
+Якщо відбувається помилка, і відсутній її обробник, то генерується подія `unhandledrejection`, і відповідний об'єкт `event` містить інформацію про помилку.
 
 Зазвичай такі помилки невідворотні, тому краще всього - інформувати користувача про проблему і, можливо, відправити інформацію про помилку на сервер.
 
diff --git a/1-js/11-async/05-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
index 8e3bf8a85..74aeba249 100644
--- a/1-js/11-async/05-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -16,7 +16,7 @@
 let promise = Promise.all(iterable);
 ```
 
-`Promise.all` приймає ітеративний об’єкт (зазвичай масив промісів) і повертає новий проміс.
+`Promise.all` приймає ітеративний об'єкт (зазвичай масив промісів) і повертає новий проміс.
 
 Новий проміс завершиться тоді, коли всі перераховані проміси завершаться, а його результатом стане масив їхніх результатів.
 
@@ -99,8 +99,8 @@ Promise.all([
 `Promise.all` не робить нічого для їх скасування, оскільки в обіцянках немає поняття "скасування". У главі [Fetch: переривання запиту](info:fetch-abort) ми розглянемо `AbortController`, який може допомогти з цим, але він не є частиною Promise API.
 ```
 
-````smart header="`Promise.all(iterable)` дозволяє передавати не-проміси в `iterable` (об’єкт, що перебирається)"
-Зазвичай `Promise.all(...)` приймає ітераційний об’єкт промісів (у більшості випадків масив). Але якщо будь-який з цих об’єктів не є промісом, він передається в результуючий масив «як є».
+````smart header="`Promise.all(iterable)` дозволяє передавати не-проміси в `iterable` (об'єкт, що перебирається)"
+Зазвичай `Promise.all(...)` приймає ітераційний об'єкт промісів (у більшості випадків масив). Але якщо будь-який з цих об'єктів не є промісом, він передається в результуючий масив «як є».
 
 Наприклад, тут результат `[1, 2, 3]`:
 
@@ -162,9 +162,9 @@ Promise.allSettled(urls.map(url => fetch(url)))
 Масив `results` у рядку `(*)` буде таким:
 ```js
 [
-  {status: 'fulfilled', value: ...об’єкт відповіді...},
-  {status: 'fulfilled', value: ...об’єкт відповіді...},
-  {status: 'rejected', reason: ...об’єкт помилки...}
+  {status: 'fulfilled', value: ...об'єкт відповіді...},
+  {status: 'fulfilled', value: ...об'єкт відповіді...},
+  {status: 'rejected', reason: ...об'єкт помилки...}
 ]
 ```
 
@@ -218,7 +218,7 @@ Promise.race([
 
 ## Promise.any
 
-Схожий на `Promise.race`, але чекає лише на перший успішно виконаний проміс і отримує його результат. Якщо ж всі надані проміси завершуються з помилкою, то повертається проміс, що завершується з помилкою за допомогою [`AggregateError`](mdn:js/AggregateError) - спеціального об’єкта помилки, який зберігає всі помилки промісів у своїй властивості `errors`.
+Схожий на `Promise.race`, але чекає лише на перший успішно виконаний проміс і отримує його результат. Якщо ж всі надані проміси завершуються з помилкою, то повертається проміс, що завершується з помилкою за допомогою [`AggregateError`](mdn:js/AggregateError) - спеціального об'єкта помилки, який зберігає всі помилки промісів у своїй властивості `errors`.
 
 Синтаксис:
 
@@ -251,7 +251,7 @@ Promise.any([
 });
 ```
 
-Як бачите, об’єкти помилок для невдалих промісів доступні по властивості `errors` об’єкта `AggregateError`.
+Як бачите, об'єкти помилок для невдалих промісів доступні по властивості `errors` об'єкта `AggregateError`.
 
 ## Promise.resolve/reject
 
@@ -271,7 +271,7 @@ let promise = new Promise(resolve => resolve(value));
 
 Цей метод використовується для сумісності, коли очікується, що функція поверне проміс.
 
-Наприклад, наведена нижче функція `loadCached` отримує URL-адресу та запам’ятовує (кешує) її вміст. Для майбутніх викликів з тією самою URL-адресою він негайно отримує попередній вміст із кешу, але використовує `Promise.resolve`, щоб значення, яке повертається, завжди було промісом:
+Наприклад, наведена нижче функція `loadCached` отримує URL-адресу та запам'ятовує (кешує) її вміст. Для майбутніх викликів з тією самою URL-адресою він негайно отримує попередній вміст із кешу, але використовує `Promise.resolve`, щоб значення, яке повертається, завжди було промісом:
 
 ```js
 let cache = new Map();
@@ -311,7 +311,7 @@ let promise = new Promise((resolve, reject) => reject(error));
 Існує 6 статичних методів класу `Promise`:
 
 1. `Promise.all(promises)` -- чекає виконання всіх промісів і повертає масив їх результатів. Якщо будь-який з наданих промісів завершується з помилкою, вона стає загальною для `Promise.all`, а всі інші результати ігноруються.
-2. `Promise.allSettled(promises)` (нещодавно доданий метод) -- чекає завершення всіх промісів і повертає їх результати у вигляді масиву об’єктів, до якого входять:
+2. `Promise.allSettled(promises)` (нещодавно доданий метод) -- чекає завершення всіх промісів і повертає їх результати у вигляді масиву об'єктів, до якого входять:
     - `status`: `"fulfilled"` або `"rejected"`
     - `value` (якщо виконано успішно) або `reason` (якщо помилка).
 3. `Promise.race(promises)` -- чекає виконання першого проміса, а його результат/помилка стає остаточним результатом.
diff --git a/1-js/11-async/07-microtask-queue/article.md b/1-js/11-async/07-microtask-queue/article.md
index a7cc2f82a..e85efc311 100644
--- a/1-js/11-async/07-microtask-queue/article.md
+++ b/1-js/11-async/07-microtask-queue/article.md
@@ -54,7 +54,7 @@ Promise.resolve()
 
 ## Необроблені помилки
 
-Пам’ятаєте подію `unhandledrejection` зі статті <info:promise-error-handling>?
+Пам'ятаєте подію `unhandledrejection` зі статті <info:promise-error-handling>?
 
 Тепер ми бачимо, як саме JavaScript дізнається про необроблені помилки.
 
@@ -109,4 +109,4 @@ window.addEventListener('unhandledrejection', event => alert(event.reason));
 
 Якщо нам потрібно гарантувати, що фрагмент коду виконується після `.then/catch/finally`, ми можемо додати його до ланцюжкового виклику `.then`.
 
-У більшості рушіїв Javascript, включаючи браузери та Node.js, концепція мікрозадач тісно пов’язана з "циклом подій" ("event loop") і "макрозадачами". Оскільки вони не мають прямого відношення до промісів, вони розглянуті в іншій частині підручника, у статті <info:event-loop>.
\ No newline at end of file
+У більшості рушіїв Javascript, включаючи браузери та Node.js, концепція мікрозадач тісно пов'язана з "циклом подій" ("event loop") і "макрозадачами". Оскільки вони не мають прямого відношення до промісів, вони розглянуті в іншій частині підручника, у статті <info:event-loop>.
\ No newline at end of file
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
index 2ae65194a..edae812b2 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
@@ -19,12 +19,12 @@ async function loadJson(url) {
   }
 }
 
-// Запитуйте ім’я користувача, поки github не поверне дійсного користувача
+// Запитуйте ім'я користувача, поки github не поверне дійсного користувача
 async function demoGithubUser() {
 
   let user;
   while(true) {
-    let name = prompt("Введіть ім’я?", "iliakan");
+    let name = prompt("Введіть ім'я?", "iliakan");
 
     try {
       user = await loadJson(`https://api.github.com/users/${name}`);
@@ -41,7 +41,7 @@ async function demoGithubUser() {
   }
 
 
-  alert(`Ім’я та прізвище: ${user.name}.`);
+  alert(`Ім'я та прізвище: ${user.name}.`);
   return user;
 }
 
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
index 0910a86dd..c0d915e51 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
@@ -25,13 +25,13 @@ function loadJson(url) {
     });
 }
 
-// Запитуйте ім’я користувача, поки github не поверне дійсного користувача
+// Запитуйте ім'я користувача, поки github не поверне дійсного користувача
 function demoGithubUser() {
-  let name = prompt("Введіть ім’я?", "iliakan");
+  let name = prompt("Введіть ім'я?", "iliakan");
 
   return loadJson(`https://api.github.com/users/${name}`)
     .then(user => {
-      alert(`Ім’я та прізвище: ${user.name}.`);
+      alert(`Ім'я та прізвище: ${user.name}.`);
       return user;
     })
     .catch(err => {
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/task.md b/1-js/11-async/08-async-await/03-async-from-regular/task.md
index aa2c27977..076c474f9 100644
--- a/1-js/11-async/08-async-await/03-async-from-regular/task.md
+++ b/1-js/11-async/08-async-await/03-async-from-regular/task.md
@@ -13,7 +13,7 @@ async function wait() {
 function f() {
   // ...що тут варто написати?
   // нам потрібно викликати async-функцію wait() і почекати, щоб отримати 10
-  // пам’ятайте, ми не можемо використовувати "await"
+  // пам'ятайте, ми не можемо використовувати "await"
 }
 ```
 
diff --git a/1-js/11-async/08-async-await/article.md b/1-js/11-async/08-async-await/article.md
index 86a9d711c..ee156283b 100644
--- a/1-js/11-async/08-async-await/article.md
+++ b/1-js/11-async/08-async-await/article.md
@@ -148,8 +148,8 @@ console.log(user);
 
 ````
 
-````smart header="`await` працює з \"thenable\"-об’єктами"
-Як і `promise.then`, `await` дозволяє нам використовувати thenable-об’єкти (їх можна викликати методом `then`). Ідея полягає в тому, що сторонній об’єкт може не бути промісом, але бути сумісним з промісом: якщо він підтримує `.then`, цього достатньо, щоб використовувати його з `await`.
+````smart header="`await` працює з \"thenable\"-об'єктами"
+Як і `promise.then`, `await` дозволяє нам використовувати thenable-об'єкти (їх можна викликати методом `then`). Ідея полягає в тому, що сторонній об'єкт може не бути промісом, але бути сумісним з промісом: якщо він підтримує `.then`, цього достатньо, щоб використовувати його з `await`.
 
 Ось приклад класу `Thenable`; нижче `await` приймає його екземпляри:
 
@@ -174,7 +174,7 @@ async function f() {
 f();
 ```
 
-Якщо `await` отримує об’єкт не-проміс із `.then`, він викликає цей метод, що надає як аргументи вбудовані функції `resolve` та `reject` (так само як це робиться для звичайного виконання `Promise`). Потім `await` чекає, поки не буде викликано один з них (у вищенаведеному прикладі це відбувається в рядку `(*)`), а потім переходить до результату.
+Якщо `await` отримує об'єкт не-проміс із `.then`, він викликає цей метод, що надає як аргументи вбудовані функції `resolve` та `reject` (так само як це робиться для звичайного виконання `Promise`). Потім `await` чекає, поки не буде викликано один з них (у вищенаведеному прикладі це відбувається в рядку `(*)`), а потім переходить до результату.
 ````
 
 ````smart header="Асинхронні методи класів"
diff --git a/1-js/12-generators-iterators/1-generators/article.md b/1-js/12-generators-iterators/1-generators/article.md
index 7fcc9a919..ef5f839fe 100644
--- a/1-js/12-generators-iterators/1-generators/article.md
+++ b/1-js/12-generators-iterators/1-generators/article.md
@@ -2,7 +2,7 @@
 
 Звичайні функції повертають лише одне, єдине значення (або нічого).
 
-Генератори можуть повертати ("yield") кілька значень, одне за одним, на вимогу. Вони чудово працюють з [об’єктами, що перебираються](info:iterable), дозволяючи легко створювати потоки даних.
+Генератори можуть повертати ("yield") кілька значень, одне за одним, на вимогу. Вони чудово працюють з [об'єктами, що перебираються](info:iterable), дозволяючи легко створювати потоки даних.
 
 ## Функції-генератори
 
@@ -18,7 +18,7 @@ function* generateSequence() {
 }
 ```
 
-Функції-генератори поводяться інакше, ніж звичайні. Коли така функція викликається, вона не запускає свій код. Замість цього вона повертає спеціальний об’єкт, який називається «об’єкт-генератор», щоб керувати її виконанням.
+Функції-генератори поводяться інакше, ніж звичайні. Коли така функція викликається, вона не запускає свій код. Замість цього вона повертає спеціальний об'єкт, який називається «об'єкт-генератор», щоб керувати її виконанням.
 
 Ось подивіться:
 
@@ -29,7 +29,7 @@ function* generateSequence() {
   return 3;
 }
 
-// "функція-генератор" створює "об’єкт-генератор"
+// "функція-генератор" створює "об'єкт-генератор"
 let generator = generateSequence();
 *!*
 alert(generator); // [object Generator]
@@ -90,7 +90,7 @@ alert(JSON.stringify(three)); // {value: 3, *!*done: true*/!*}
 
 Тепер генератор виконався. Ми можемо побачити це за допомогою `done:true` і обробити `value:3` як кінцевий результат.
 
-Нові виклики `generator.next()` більше не мають сенсу. Якщо ми їх робимо, вони повертають той самий об’єкт: `{done: true}`.
+Нові виклики `generator.next()` більше не мають сенсу. Якщо ми їх робимо, вони повертають той самий об'єкт: `{done: true}`.
 
 ```smart header="`function* f(…)` чи `function *f(…)`?"
 Обидва синтаксиси правильні.
@@ -100,7 +100,7 @@ alert(JSON.stringify(three)); // {value: 3, *!*done: true*/!*}
 
 ## Перебір генераторів
 
-Як ви, напевно, вже здогадалися, дивлячись на метод `next()`, генератори є [об’єктами, що перебираються](info:iterable).
+Як ви, напевно, вже здогадалися, дивлячись на метод `next()`, генератори є [об'єктами, що перебираються](info:iterable).
 
 Ми можемо перебирати їх значення за допомогою `for..of`:
 
@@ -140,7 +140,7 @@ for(let value of generator) {
 }
 ```
 
-Оскільки генератори є об’єктами, що перебираються, ми можемо використовувати всю пов’язану з ними функціональність, наприклад синтаксис розширення `...`:
+Оскільки генератори є об'єктами, що перебираються, ми можемо використовувати всю пов'язану з ними функціональність, наприклад синтаксис розширення `...`:
 
 ```js run
 function* generateSequence() {
@@ -154,11 +154,11 @@ let sequence = [0, ...generateSequence()];
 alert(sequence); // 0, 1, 2, 3
 ```
 
-У наведеному вище коді `...generateSequence()` перетворює об’єкт-генератор, що перебирається, в масив елементів (докладніше про синтаксис розширення читайте у главі [](info:rest-parameters-spread#spread-syntax))
+У наведеному вище коді `...generateSequence()` перетворює об'єкт-генератор, що перебирається, в масив елементів (докладніше про синтаксис розширення читайте у главі [](info:rest-parameters-spread#spread-syntax))
 
-## Використання генераторів для об’єктів, що перебираються
+## Використання генераторів для об'єктів, що перебираються
 
-Деякий час тому в главі [](info:iterable) ми створили об’єкт `range`, що перебирається та повертає значення `from..to`.
+Деякий час тому в главі [](info:iterable) ми створили об'єкт `range`, що перебирається та повертає значення `from..to`.
 
 Ось, давайте згадаємо код:
 
@@ -169,15 +169,15 @@ let range = {
 
   // for..of range викликає цей метод один раз на самому початку
   [Symbol.iterator]() {
-    // ...він повертає об’єкт, що перебирається:
-    // далі for..of працює лише з цим об’єктом, запитуючи в нього наступні значення
+    // ...він повертає об'єкт, що перебирається:
+    // далі for..of працює лише з цим об'єктом, запитуючи в нього наступні значення
     return {
       current: this.from,
       last: this.to,
 
       // next() викликається при кожній ітерації цикла for..of
       next() {
-        // повинно повернути значення як об’єкт {done:.., value :...}
+        // повинно повернути значення як об'єкт {done:.., value :...}
         if (this.current <= this.last) {
           return { done: false, value: this.current++ };
         } else {
@@ -188,11 +188,11 @@ let range = {
   }
 };
 
-// при переборі об’єкта range повертаються числа від range.from до range.to
+// при переборі об'єкта range повертаються числа від range.from до range.to
 alert([...range]); // 1,2,3,4,5
 ```
 
-Ми можемо використовувати функцію-генератор для перебору об’єкта, вказавши її як `Symbol.iterator`.
+Ми можемо використовувати функцію-генератор для перебору об'єкта, вказавши її як `Symbol.iterator`.
 
 Ось той самий `range`, але набагато компактніший:
 
@@ -244,7 +244,7 @@ function* generateSequence(start, end) {
 
 Ми можемо використовувати цю послідовність, наприклад створювати паролі, вибираючи з неї символи (можна також додати символи пунктуації), але давайте спочатку згенеруємо її.
 
-У звичайній функції, щоб об’єднати результати кількох інших функцій, ми викликаємо їх, зберігаємо результати, а потім об’єднуємо в кінці.
+У звичайній функції, щоб об'єднати результати кількох інших функцій, ми викликаємо їх, зберігаємо результати, а потім об'єднуємо в кінці.
 
 Для генераторів існує спеціальний синтаксис `yield*` для "вбудовування" (компонування) одного генератора в інший.
 
@@ -312,11 +312,11 @@ for(let code of generateAlphaNum()) {
 alert(str); // 0..9A..Za..z
 ```
 
-Композиція генераторів - це природний спосіб вставити потік одного генератора в інший. Вона не використовує додаткову пам’ять для зберігання проміжних результатів.
+Композиція генераторів - це природний спосіб вставити потік одного генератора в інший. Вона не використовує додаткову пам'ять для зберігання проміжних результатів.
 
 ## "yield" — дорога з двостороннім рухом
 
-До цього моменту генератори були схожі на об’єкти, що перебираються, зі спеціальним синтаксисом для генерування значень. Але насправді вони набагато потужніші й гнучкіші.
+До цього моменту генератори були схожі на об'єкти, що перебираються, зі спеціальним синтаксисом для генерування значень. Але насправді вони набагато потужніші й гнучкіші.
 
 Це тому, що `yield` є дорогою з двостороннім рухом: він не лише повертає результат назовні, але також може передати значення всередину генератора.
 
@@ -476,7 +476,7 @@ g.next();        // { value: undefined, done: true }
 - Усередині генераторів (лише в них) існує оператор `yield`.
 - Зовнішній код і генератор можуть обмінюватися результатами за допомогою викликів `next/yield`.
 
-У сучасному JavaScript генератори використовуються рідко. Але іноді вони стають у пригоді, оскільки здатність функції обмінюватися даними з кодом, що її викликає, під час самого виконання є досить унікальною. І, безсумнівно, вони чудово підходять для створення об’єктів, що перебираються.
+У сучасному JavaScript генератори використовуються рідко. Але іноді вони стають у пригоді, оскільки здатність функції обмінюватися даними з кодом, що її викликає, під час самого виконання є досить унікальною. І, безсумнівно, вони чудово підходять для створення об'єктів, що перебираються.
 
 Крім того, у наступному розділі ми ознайомимося з асинхронними генераторами, які використовуються для зчитування потоків асинхронно згенерованих даних (наприклад, які посторінково завантажуються з мережі) у циклах `for await ... of`.
 
diff --git a/1-js/12-generators-iterators/2-async-iterators-generators/article.md b/1-js/12-generators-iterators/2-async-iterators-generators/article.md
index 9fe48e81f..6556695c2 100644
--- a/1-js/12-generators-iterators/2-async-iterators-generators/article.md
+++ b/1-js/12-generators-iterators/2-async-iterators-generators/article.md
@@ -9,7 +9,7 @@
 
 Згадаймо тему про ітератори.
 
-Ідея полягає в тому, що ми маємо об’єкт, наприклад, `range`:
+Ідея полягає в тому, що ми маємо об'єкт, наприклад, `range`:
 ```js
 let range = {
   from: 1,
@@ -19,15 +19,15 @@ let range = {
 
 ...І ми хотіли б використовувати для нього цикл `for..of`, наприклад, `for(value of range)`, щоб отримати значення від `1` до `5`.
 
-Інакше кажучи, ми хочемо додати до об’єкта *можливість перебирання* (ітерації).
+Інакше кажучи, ми хочемо додати до об'єкта *можливість перебирання* (ітерації).
 
 Це можна реалізувати за допомогою спеціального методу з назвою `Symbol.iterator`:
 
-- Цей метод викликається конструкцією `for..of`, коли запускається цикл, і він повинен повернути об’єкт із методом `next`.
+- Цей метод викликається конструкцією `for..of`, коли запускається цикл, і він повинен повернути об'єкт із методом `next`.
 - На кожній ітерації викликається метод `next()`, щоб отримати наступне значення.
 - `next()` має повертати значення у формі `{done: true/false, value:<loop value>}`, де `done:true` означає кінець циклу.
 
-Ось реалізація об’єкта `range`, що перебирається:
+Ось реалізація об'єкта `range`, що перебирається:
 
 ```js run
 let range = {
@@ -65,17 +65,17 @@ for(let value of range) {
 
 Асинхронна ітерація потрібна тоді, коли значення надходять асинхронно: після `setTimeout` або іншого виду затримки.
 
-Найпоширеніший випадок полягає в тому, що об’єкту потрібно зробити мережевий запит для доставлення наступного значення. Реальний приклад цього ми побачимо трохи пізніше.
+Найпоширеніший випадок полягає в тому, що об'єкту потрібно зробити мережевий запит для доставлення наступного значення. Реальний приклад цього ми побачимо трохи пізніше.
 
-Для того, щоб перебирати об’єкт асинхронно:
+Для того, щоб перебирати об'єкт асинхронно:
 
 1. Використовуйте `Symbol.asyncIterator` замість `Symbol.iterator`.
 2. Метод `next()` повинен повертати проміс (який має містити наступне значення).
    - Це робиться за допомогою ключового слова `async`. Ось так: `async next()`.
-3. Щоб перебрати такий об’єкт, ми повинні використовувати цикл `for await (let item of iterable)`.
+3. Щоб перебрати такий об'єкт, ми повинні використовувати цикл `for await (let item of iterable)`.
    - Зверніть увагу на слово `await`.
 
-Як початковий приклад, створімо об’єкт `range`, що перебирається. Він буде подібний до попереднього, проте повертатиме значення асинхронно -- по одному за секунду.
+Як початковий приклад, створімо об'єкт `range`, що перебирається. Він буде подібний до попереднього, проте повертатиме значення асинхронно -- по одному за секунду.
 
 Все, що нам потрібно зробити -- це внести кілька замін у коді вище:
 
@@ -123,8 +123,8 @@ let range = {
 
 Як бачимо, структура схожа на звичайні ітератори:
 
-1. Щоб об’єкт перебирався асинхронно, він повинен мати метод `Symbol.asyncIterator` `(1)`.
-2. Цей метод повинен повертати об’єкт із методом `next()`, який повертає проміс `(2)`.
+1. Щоб об'єкт перебирався асинхронно, він повинен мати метод `Symbol.asyncIterator` `(1)`.
+2. Цей метод повинен повертати об'єкт із методом `next()`, який повертає проміс `(2)`.
 3. Метод `next()` не повинен бути `async`, це може бути звичайний метод, що повертає проміс, але `async` дозволяє нам використовувати `await`, тому це зручно. Тут ми просто затримуємося на секунду `(3)`.
 4. Для ітерації ми використовуємо `for await(let value of range)` `(4)`, а саме додаємо "await" після "for". Він викликає `range[Symbol.asyncIterator]()` один раз, а потім його `next()` для значень.
 
@@ -171,7 +171,7 @@ for(let value of generateSequence(1, 5)) {
 }
 ```
 
-Як ми вже знаємо, щоб об’єкт міг перебиратися, ми повинні додати до нього `Symbol.iterator`.
+Як ми вже знаємо, щоб об'єкт міг перебиратися, ми повинні додати до нього `Symbol.iterator`.
 
 ```js
 let range = {
@@ -179,7 +179,7 @@ let range = {
   to: 5,
 *!*
   [Symbol.iterator]() {
-    return <об’єкт з next, щоб зробити діапазон ітерабельним>
+    return <об'єкт з next, щоб зробити діапазон ітерабельним>
   }
 */!*
 }
@@ -214,7 +214,7 @@ for(let value of range) {
 
 ## Асинхронні генератори (нарешті)
 
-Для більшості практичних застосувань, коли ми хочемо створити об’єкт, який асинхронно генерує послідовність значень, ми можемо використовувати асинхронний генератор.
+Для більшості практичних застосувань, коли ми хочемо створити об'єкт, який асинхронно генерує послідовність значень, ми можемо використовувати асинхронний генератор.
 
 Синтаксис простий: додайте `async` перед `function*`. Це зробить генератор асинхронним.
 
@@ -248,7 +248,7 @@ for(let value of range) {
 Оскільки генератор є асинхронним, ми можемо використовувати всередині нього `await`, проміси, виконувати мережеві запити тощо.
 
 ````smart header="Різниця під капотом"
-Якщо ви досвідчений читач і пам’ятаєте деталі про генератори, то знаєте, що технічно в них є внутрішня різниця.
+Якщо ви досвідчений читач і пам'ятаєте деталі про генератори, то знаєте, що технічно в них є внутрішня різниця.
 
 Для асинхронних генераторів метод `generator.next()` є асинхронним, він повертає проміси.
 
@@ -266,7 +266,7 @@ result = await generator.next(); // result = {value: ..., done: true/false}
 
 Подібно до цього, асинхронні генератори можна використовувати як `Symbol.asyncIterator` для реалізації асинхронної ітерації.
 
-Наприклад, ми можемо змусити об’єкт `range` генерувати значення асинхронно, раз за секунду, замінивши синхронний `Symbol.iterator` на асинхронний `Symbol.asyncIterator`:
+Наприклад, ми можемо змусити об'єкт `range` генерувати значення асинхронно, раз за секунду, замінивши синхронний `Symbol.iterator` на асинхронний `Symbol.asyncIterator`:
 
 ```js run
 let range = {
@@ -299,7 +299,7 @@ let range = {
 Тепер значення надходять із затримкою в 1 секунду між ними.
 
 ```smart
-Технічно ми можемо додати до об’єкта як `Symbol.iterator`, так і `Symbol.asyncIterator`, тому він може перебиратися як синхронно (`for..of`), так і асинхронно (`for await..of`).
+Технічно ми можемо додати до об'єкта як `Symbol.iterator`, так і `Symbol.asyncIterator`, тому він може перебиратися як синхронно (`for..of`), так і асинхронно (`for await..of`).
 
 Але на практиці це було б дивно.
 ```
diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md
index a56a22602..eaf4fde6c 100644
--- a/1-js/13-modules/01-modules-intro/article.md
+++ b/1-js/13-modules/01-modules-intro/article.md
@@ -5,7 +5,7 @@
 
 Досить тривалий час JavaScript існував без синтаксису модуля на мовному рівні. Це не було проблемою, тому що спочатку скрипти були невеликими й простими.
 
-Але з часом скрипти ставали все складнішими, тому спільнота винайшла різноманітні способи організувати код у модулі. З’явилися бібліотеки для динамічного завантаження модулів.
+Але з часом скрипти ставали все складнішими, тому спільнота винайшла різноманітні способи організувати код у модулі. З'явилися бібліотеки для динамічного завантаження модулів.
 
 Наприклад:
 
@@ -15,7 +15,7 @@
 
 Тепер усі вони поступово стають частиною історії, хоча їх можна знайти в старих скриптах.
 
-Система модулів на рівні мови з’явилася у стандарті JavaScript у 2015 році та поступово еволюціонувала. На цей час вона підтримується більшістю браузерів та Node.js. Далі ми вивчатимемо саме її.
+Система модулів на рівні мови з'явилася у стандарті JavaScript у 2015 році та поступово еволюціонувала. На цей час вона підтримується більшістю браузерів та Node.js. Далі ми вивчатимемо саме її.
 
 ## Що таке модуль?
 
@@ -114,7 +114,7 @@ sayHi('Іван'); // Привіт, Іван!
 ```
 
 ```smart
-В браузері є можливість створити глобальну змінну рівня вікна браузера шляхом явного призначення її до об’єкту `window`, наприклад: `window.user = "Іван"`.
+В браузері є можливість створити глобальну змінну рівня вікна браузера шляхом явного призначення її до об'єкту `window`, наприклад: `window.user = "Іван"`.
 
 Тоді всі скрипти типу `type="module"` і без нього будуть "бачити" змінну user.
 
@@ -152,7 +152,7 @@ import `./alert.js`; // (нічого не покаже)
 
 Тепер більш ускладнений приклад.
 
-Уявімо, що модуль експортує об’єкт:
+Уявімо, що модуль експортує об'єкт:
 
 ```js
 // 📁 admin.js
@@ -161,9 +161,9 @@ export let admin = {
 };
 ```
 
-Якщо модуль імпортується в кількох файлах, код модуля буде виконано лише один раз, об’єкт `admin` буде створено і надалі буде переданий всім імпортерам.
+Якщо модуль імпортується в кількох файлах, код модуля буде виконано лише один раз, об'єкт `admin` буде створено і надалі буде переданий всім імпортерам.
 
-Всі імпортери отримають один-єдиний об’єкт `admin`:
+Всі імпортери отримають один-єдиний об'єкт `admin`:
 
 ```js
 // 📁 1.js
@@ -175,25 +175,25 @@ import {admin} from './admin.js';
 alert(admin.name); // Pete
 
 *!*
-// Обидва файли, 1.js і 2.js, імпортують той самий об’єкт
-// Зміни, зроблені в 1.js, з’являться в 2.js
+// Обидва файли, 1.js і 2.js, імпортують той самий об'єкт
+// Зміни, зроблені в 1.js, з'являться в 2.js
 */!*
 ```
 
-Як ви бачите, коли `1.js` змінює значення властивості `name` об’єкту `admin`, тоді інші модулі теж побачать ці зміни.
+Як ви бачите, коли `1.js` змінює значення властивості `name` об'єкту `admin`, тоді інші модулі теж побачать ці зміни.
 
-Ще раз зауважимо -- модуль виконується лише один раз. Генерується експорт і після цього передається всім імпортерам, тому, якщо щось зміниться в об’єкті `admin`, то інші модулі теж побачать ці зміни.
+Ще раз зауважимо -- модуль виконується лише один раз. Генерується експорт і після цього передається всім імпортерам, тому, якщо щось зміниться в об'єкті `admin`, то інші модулі теж побачать ці зміни.
 
 **Така поведінка дозволяє *конфігурувати* модулі під час першого імпорту. Ми можемо встановити його властивості один раз, і в подальших імпортах він буде налаштованим.**
 
-Іншими словами, модуль може забезпечити загальну функціональність, яка потребує налаштування. Наприклад для аутентифікації підготувати облікові дані. Потім він може експортувати об’єкт конфігурації, очікуючи, що зовнішній код буде посилатися на нього.
+Іншими словами, модуль може забезпечити загальну функціональність, яка потребує налаштування. Наприклад для аутентифікації підготувати облікові дані. Потім він може експортувати об'єкт конфігурації, очікуючи, що зовнішній код буде посилатися на нього.
 
 Класичний шаблон використання:
-1. Модуль експортує деякі значення конфігурації, наприклад, об’єкт конфігурації.
+1. Модуль експортує деякі значення конфігурації, наприклад, об'єкт конфігурації.
 2. При першому імпорті ми його ініціалізуємо, записуємо в його властивості. Це може зробити скрипт програми верхнього рівня.
 3. Подальші імпорти використовують цей модуль.
 
-Наприклад, модуль `admin.js` може забезпечувати певну функціональність (наприклад, аутентифікацію), але очікуймо, що облікові дані надходять в об’єкт `config` ззовні:
+Наприклад, модуль `admin.js` може забезпечувати певну функціональність (наприклад, аутентифікацію), але очікуймо, що облікові дані надходять в об'єкт `config` ззовні:
 
 ```js
 // 📁 admin.js
@@ -204,9 +204,9 @@ export function sayHi() {
 }
 ```
 
-В цьому прикладі, `admin.js` експортує `config` об’єкт (спочатку порожній, але також може мати властивості за замовчуванням).
+В цьому прикладі, `admin.js` експортує `config` об'єкт (спочатку порожній, але також може мати властивості за замовчуванням).
 
-Потім у `init.js`, першому скрипту нашої програми, ми імпортуємо `config` об’єкт і записуємо дані для ініціалізації  `config.user`:
+Потім у `init.js`, першому скрипту нашої програми, ми імпортуємо `config` об'єкт і записуємо дані для ініціалізації  `config.user`:
 
 ```js
 // 📁 init.js
@@ -228,7 +228,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 ### import.meta
 
-Об’єкт `import.meta` містить інформацію про поточний модуль.
+Об'єкт `import.meta` містить інформацію про поточний модуль.
 
 Вміст залежить від оточення. У браузері він містить посилання на скрипт або посилання на поточну вебсторінку, якщо модуль вбудований в HTML:
 
@@ -245,7 +245,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 У модулі на верхньому рівні `this` не визначено (undefined).
 
-Порівняємо з не-модульними скриптами, там `this` -- глобальний об’єкт:
+Порівняємо з не-модульними скриптами, там `this` -- глобальний об'єкт:
 
 ```html run height=0
 <script>
@@ -259,7 +259,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 ## Особливості у браузерах
 
-Є кілька інших, саме браузерних особливостей скриптів пов’язаних з `type="module"`.
+Є кілька інших, саме браузерних особливостей скриптів пов'язаних з `type="module"`.
 
 Якщо ви читаєте матеріал вперше або якщо не збираєтеся використовувати модулі в браузерах, то зараз можете пропустити цю секцію.
 
@@ -312,7 +312,7 @@ sayHi(); // Ready to serve, *!*Pete*/!*!
 
 Скрипт виконає імпорт (завантажить `./analytics.js`) і відразу запуститься, навіть, якщо HTML документ ще не завантажився чи якщо інші скрипти все ще завантажуються.
 
-Це дуже корисно, коли модуль ні з чим не пов’язаний, наприклад, для лічильників, реклами, обробників подій.
+Це дуже корисно, коли модуль ні з чим не пов'язаний, наприклад, для лічильників, реклами, обробників подій.
 
 ```html
 <!-- завантажуються залежності (analytics.js) і скрипт запускається -->
@@ -373,7 +373,7 @@ import {sayHi} from 'sayHi'; // Помилка, "голий" модуль
 
 ## Інструменти збирання
 
-У реальному житті модулі в браузерах рідко використовуються у «сирому» вигляді. Зазвичай ми об’єднуємо модулі разом, використовуючи спеціальний інструмент, наприклад [Webpack](https://webpack.js.org/) і після викладаємо код на робочий сервер.
+У реальному житті модулі в браузерах рідко використовуються у «сирому» вигляді. Зазвичай ми об'єднуємо модулі разом, використовуючи спеціальний інструмент, наприклад [Webpack](https://webpack.js.org/) і після викладаємо код на робочий сервер.
 
 Одна з переваг використання збирача -- він надає більший контроль над тим, як модулі шукаються, дозволяє використовувати голі модулі та інші "власні" налаштування, наприклад CSS/HTML-модулі.
 
@@ -389,7 +389,7 @@ import {sayHi} from 'sayHi'; // Помилка, "голий" модуль
     - Сучасний синтаксис JavaScript також може бути трансформований на попередній стандарт, зі схожою функціональністю, наприклад, за допомогою [Babel](https://babeljs.io/).
     - Отриманий файл можна мінімізувати (видалити пробіли, замінити назви змінних на більш короткі й т.д.).
 
-Якщо ми використовуємо інструменти збирання, вони об’єднують модулі разом в один або кілька файлів, і замінюють `import/export` на свої виклики. Тому підсумкове збирання можна підключати й без атрибута `type="module"`, а як звичайний скрипт:
+Якщо ми використовуємо інструменти збирання, вони об'єднують модулі разом в один або кілька файлів, і замінюють `import/export` на свої виклики. Тому підсумкове збирання можна підключати й без атрибута `type="module"`, а як звичайний скрипт:
 
 ```html
 <!-- Припустимо, що ми зібрали bundle.js, використовуючи, наприклад, утиліту Webpack -->
@@ -400,7 +400,7 @@ import {sayHi} from 'sayHi'; // Помилка, "голий" модуль
 
 ## Підсумки
 
-Підіб’ємо підсумки:
+Підіб'ємо підсумки:
 
 1. Модуль -- це файл. Щоб працював `import/export`, потрібно для браузерів вказувати атрибут `<script type="module">`. Модулі мають ряд особливостей:
     - Відкладене (deferred) виконання за замовчуванням.
diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
index ab82882b6..0a1c4a7bc 100644
--- a/1-js/13-modules/02-import-export/article.md
+++ b/1-js/13-modules/02-import-export/article.md
@@ -77,7 +77,7 @@ sayHi('Іван'); // Привіт, Іван!
 sayBye('Іван'); // Бувай, Іван!
 ```
 
-Якщо потрібно імпортувати дуже багато сутностей, ми можемо імпортувати все, як об’єкт з використанням `import * as <obj>`, наприклад:
+Якщо потрібно імпортувати дуже багато сутностей, ми можемо імпортувати все, як об'єкт з використанням `import * as <obj>`, наприклад:
 
 ```js
 // 📁 main.js
@@ -97,7 +97,7 @@ say.sayBye('Іван');
 2. Явний список того, що потрібно імпортувати дає краще розуміння структури коду: що використано та в якому місці. Також дозволяє підтримувати та рефакторити код легше.
 
 ```smart header="Не бійтеся імпортувати занадто багато"
-Сучасні інструменти збірки, такі як [webpack](https://webpack.js.org/) та інші, об’єднують модулі разом і оптимізують їх для прискорення завантаження. Вони також видаляють імпорти, що не використовуються.
+Сучасні інструменти збірки, такі як [webpack](https://webpack.js.org/) та інші, об'єднують модулі разом і оптимізують їх для прискорення завантаження. Вони також видаляють імпорти, що не використовуються.
 
 Наприклад, якщо ви `import * as library` з величезної бібліотеки коду, а потім використаєте лише кілька методів, тоді невикористані методи [не будуть включені](https://github.com/webpack/webpack/tree/main/examples/harmony-unused#examplejs) у оптимізований бандл.
 ```
@@ -189,13 +189,13 @@ new User('John');
 В прикладі правильно використано типові експорти:
 
 ```js
-export default class { // відсутнє ім’я класу
+export default class { // відсутнє ім'я класу
   constructor() { ... }
 }
 ```
 
 ```js
-export default function(user) { // відсутнє ім’я функції
+export default function(user) { // відсутнє ім'я функції
   alert(`Привіт, ${user}!`);
 }
 ```
@@ -215,7 +215,7 @@ export class { // Помилка! (типовий експорт потребу
 }
 ```
 
-### Ім’я "default"
+### Ім'я "default"
 
 В деяких ситуаціях ключове слово `default` використовують для позначення типового імпорту.
 
@@ -268,14 +268,14 @@ new User('Іван');
 
 Іменовані імпорти є явними. Нам потрібно точно перелічити все, що імпортуємо - це є перевагою.
 
-Іменовані експорти змушують нас використовувати точне ім’я сутності для імпорту:
+Іменовані експорти змушують нас використовувати точне ім'я сутності для імпорту:
 
 ```js
 import {User} from './user.js';
-// import {MyUser} не спрацює, оскільки ім’я повинно бути {User}
+// import {MyUser} не спрацює, оскільки ім'я повинно бути {User}
 ```
 
-...В той час, як для типового імпорту нам завжди потрібно обрати ім’я:
+...В той час, як для типового імпорту нам завжди потрібно обрати ім'я:
 
 ```js
 import User from './user.js'; // спрацює
@@ -285,7 +285,7 @@ import MyUser from './user.js'; // спрацює теж
 
 Таким чином різні члени команд можуть використовувати різні імена для імпорту однакових сутностей і це не дуже добре.
 
-Зазвичай, щоб уникати цього і тримати код узгодженим, існує правило - імпортована змінна повинна мати ім’я, що відповідає імені файлу:
+Зазвичай, щоб уникати цього і тримати код узгодженим, існує правило - імпортована змінна повинна мати ім'я, що відповідає імені файлу:
 
 ```js
 import User from './user.js';
@@ -310,7 +310,7 @@ export {default as User} from './user.js'; // реекспорт default
 
 Навіщо нам це може знадобитися? Розглянемо практичний спосіб використання.
 
-Уявімо, що нам потрібно написати "пакунок": директорію з багатьма модулями, що експортує певний функціонал (інструменти як NPM дозволяють публікувати та розповсюджувати такі пакунки, але ми не зобов’язані їх використовувати). Багато таких пакунків використовуються в ролі допоміжних, для внутрішнього використання всередині інших модулів.
+Уявімо, що нам потрібно написати "пакунок": директорію з багатьма модулями, що експортує певний функціонал (інструменти як NPM дозволяють публікувати та розповсюджувати такі пакунки, але ми не зобов'язані їх використовувати). Багато таких пакунків використовуються в ролі допоміжних, для внутрішнього використання всередині інших модулів.
 
 Файлова структура може мати такий вигляд:
 ```
diff --git a/1-js/13-modules/03-modules-dynamic-imports/article.md b/1-js/13-modules/03-modules-dynamic-imports/article.md
index ebf22cee7..3ee647f0b 100644
--- a/1-js/13-modules/03-modules-dynamic-imports/article.md
+++ b/1-js/13-modules/03-modules-dynamic-imports/article.md
@@ -28,7 +28,7 @@ if(...) {
 
 ## Вираз import()
 
-Вираз `import(module)` завантажує модуль і повертає проміс, результатом якого стає об’єкт модуля, що містить усі його експорти.
+Вираз `import(module)` завантажує модуль і повертає проміс, результатом якого стає об'єкт модуля, що містить усі його експорти.
 
 Ми можемо використати його у будь-якому місці коду, наприклад, так:
 
@@ -36,7 +36,7 @@ if(...) {
 let modulePath = prompt("Який модуль завантажити?");
 
 import(modulePath)
-  .then(obj => <об’єкт модуля>)
+  .then(obj => <об'єкт модуля>)
   .catch(err => <помилка завантаження, наприклад якщо немає такого модуля>)
 ```
 
@@ -73,7 +73,7 @@ export default function() {
 }
 ```
 
-...То для доступу до нього нам слід узяти властивість `default` об’єкту модуля:
+...То для доступу до нього нам слід узяти властивість `default` об'єкту модуля:
 
 ```js
 let obj = await import('./say.js');
diff --git a/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md b/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md
index 49d396bda..4270fafb3 100644
--- a/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md
+++ b/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md
@@ -6,7 +6,7 @@
 
 Це може допомогти виявити помилки програмування раніше.
 
-Напишіть функцію `wrap(target)`, яка приймає об’єкт `target` і повертає проксі, що додає цей аспект функціональності.
+Напишіть функцію `wrap(target)`, яка приймає об'єкт `target` і повертає проксі, що додає цей аспект функціональності.
 
 Ось як це має працювати:
 
diff --git a/1-js/99-js-misc/01-proxy/03-observable/solution.md b/1-js/99-js-misc/01-proxy/03-observable/solution.md
index a58d05c1b..fbcea6f24 100644
--- a/1-js/99-js-misc/01-proxy/03-observable/solution.md
+++ b/1-js/99-js-misc/01-proxy/03-observable/solution.md
@@ -1,6 +1,6 @@
 Рішення складається з двох частин:
 
-1. Щоразу, коли викликається `.observe(handler)`, нам потрібно десь запам’ятати обробник, щоб мати можливість викликати його пізніше. Ми можемо зберігати обробники прямо в об’єкті, використовуючи наш символ як ключ властивості.
+1. Щоразу, коли викликається `.observe(handler)`, нам потрібно десь запам'ятати обробник, щоб мати можливість викликати його пізніше. Ми можемо зберігати обробники прямо в об'єкті, використовуючи наш символ як ключ властивості.
 2. Нам потрібен проксі з пасткою `set` для виклику обробників у разі будь-яких змін.
 
 ```js run
@@ -18,7 +18,7 @@ function makeObservable(target) {
   // 2. Створимо проксі для обробки змін
   return new Proxy(target, {
     set(target, property, value, receiver) {
-      let success = Reflect.set(...arguments); // перенаправимо операцію на об’єкт
+      let success = Reflect.set(...arguments); // перенаправимо операцію на об'єкт
       if (success) { // якщо під час запису властивості не було помилок
         // викличемо всі обробники
         target[handlers].forEach(handler => handler(property, value));
diff --git a/1-js/99-js-misc/01-proxy/03-observable/task.md b/1-js/99-js-misc/01-proxy/03-observable/task.md
index ae3bdc576..c2c8561c1 100644
--- a/1-js/99-js-misc/01-proxy/03-observable/task.md
+++ b/1-js/99-js-misc/01-proxy/03-observable/task.md
@@ -1,7 +1,7 @@
 
 # Observable
 
-Створіть функцію `makeObservable(target)`, яка "робить об’єкт доступним для спостереження", повертаючи проксі.
+Створіть функцію `makeObservable(target)`, яка "робить об'єкт доступним для спостереження", повертаючи проксі.
 
 Ось як це має працювати:
 
@@ -20,7 +20,7 @@ user.observe((key, value) => {
 user.name = "Іван"; // сповіщає: SET name=Іван
 ```
 
-Іншими словами, об’єкт, повернутий `makeObservable`, такий же, як оригінальний, але також має метод `observe(handler)`, який встановлює функцію `handler` для виклику при будь-якій зміні властивості.
+Іншими словами, об'єкт, повернутий `makeObservable`, такий же, як оригінальний, але також має метод `observe(handler)`, який встановлює функцію `handler` для виклику при будь-якій зміні властивості.
 
 Щоразу, коли властивість змінюється, викликається `handler(key, value)` з назвою та значенням властивості.
 
diff --git a/1-js/99-js-misc/01-proxy/article.md b/1-js/99-js-misc/01-proxy/article.md
index a9a0c4011..d6e562727 100644
--- a/1-js/99-js-misc/01-proxy/article.md
+++ b/1-js/99-js-misc/01-proxy/article.md
@@ -1,6 +1,6 @@
 # Proxy та Reflect
 
-Об’єкт `Proxy` обгортає інший об’єкт і перехоплює операції, такі як читання/запис властивостей та інші, за бажанням обробляючи їх самостійно, або прозоро дозволяючи об’єкту обробляти їх.
+Об'єкт `Proxy` обгортає інший об'єкт і перехоплює операції, такі як читання/запис властивостей та інші, за бажанням обробляючи їх самостійно, або прозоро дозволяючи об'єкту обробляти їх.
 
 Проксі використовуються в багатьох бібліотеках і деяких фреймворках браузера. У цьому розділі ми побачимо багато випадків вирішення реальних задач.
 
@@ -12,8 +12,8 @@
 let proxy = new Proxy(target, handler)
 ```
 
-- `target` -- об’єкт для обгортання, може бути будь-чим, включаючи функції.
-- `handler` -- конфігурація проксі: об’єкт з "пастками" ("traps"), методами, які перехоплюють операції, наприклад, пастка `get` - для зчитування властивості `target`, пастка `set` - для запису властивості в `target` і так далі.
+- `target` -- об'єкт для обгортання, може бути будь-чим, включаючи функції.
+- `handler` -- конфігурація проксі: об'єкт з "пастками" ("traps"), методами, які перехоплюють операції, наприклад, пастка `get` - для зчитування властивості `target`, пастка `set` - для запису властивості в `target` і так далі.
 
 Для операцій над `proxy`, якщо в `handler` є відповідна пастка, то вона спрацьовує, і проксі має шанс обробити її, інакше операція виконується над `target`.
 
@@ -24,7 +24,7 @@ let target = {};
 let proxy = new Proxy(target, {}); // порожній handler
 
 proxy.test = 5; // записуємо в проксі (1)
-alert(target.test); // 5, властивість з’явилася у target!
+alert(target.test); // 5, властивість з'явилася у target!
 
 alert(proxy.test); // 5, ми також можемо зчитати її з проксі (2)
 
@@ -41,17 +41,17 @@ for(let key in proxy) alert(key); // test, ітерація працює (3)
 
 ![](proxy.svg)
 
-`Proxy` -- це особливий "екзотичний об’єкт". Він не має своїх властивостей. З порожнім `handler` він прозоро перенаправляє операції до `target`.
+`Proxy` -- це особливий "екзотичний об'єкт". Він не має своїх властивостей. З порожнім `handler` він прозоро перенаправляє операції до `target`.
 
 Щоб активувати більше можливостей, додаймо пастки.
 
 Що саме ми можемо ними перехопити?
 
-Для більшості операцій над об’єктами в специфікації JavaScript є так званий "внутрішній метод", який на найнижчому рівні описує, як його виконувати. Наприклад, `[[Get]]`, внутрішній метод для зчитування властивості, `[[Set]]`, внутрішній метод для запису властивості тощо. Ці методи використовуються лише в специфікації, ми не можемо називати їх безпосередньо по імені.
+Для більшості операцій над об'єктами в специфікації JavaScript є так званий "внутрішній метод", який на найнижчому рівні описує, як його виконувати. Наприклад, `[[Get]]`, внутрішній метод для зчитування властивості, `[[Set]]`, внутрішній метод для запису властивості тощо. Ці методи використовуються лише в специфікації, ми не можемо називати їх безпосередньо по імені.
 
 Пастки проксі перехоплюють виклики цих методів. Вони перераховані в [специфікації Proxy](https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots) і в таблиці нижче.
 
-Для кожного внутрішнього методу в цій таблиці є пастка: ім’я методу, яке ми можемо додати до параметра `handler` нового проксі, щоб перехопити операцію:
+Для кожного внутрішнього методу в цій таблиці є пастка: ім'я методу, яке ми можемо додати до параметра `handler` нового проксі, щоб перехопити операцію:
 
 | Внутрішній Метод | Метод Пастки | Викликається, коли... |
 |-----------------|----------------|-------------|
@@ -78,7 +78,7 @@ JavaScript встановлює деякі інваріанти -- умови, 
 - ...і так далі, ми побачимо більше у прикладах нижче.
 
 Є й інші інваріанти, наприклад:
-- `[[GetPrototypeOf]]`, застосований до об’єкта проксі, має повертати те саме значення, що й `[[GetPrototypeOf]]`, застосоване до цільового об’єкта проксі. Іншими словами, зчитування прототипу проксі завжди має повертати прототип цільового об’єкта.
+- `[[GetPrototypeOf]]`, застосований до об'єкта проксі, має повертати те саме значення, що й `[[GetPrototypeOf]]`, застосоване до цільового об'єкта проксі. Іншими словами, зчитування прототипу проксі завжди має повертати прототип цільового об'єкта.
 
 Пастки можуть перехопити ці операції, але вони повинні дотримуватися цих правил.
 
@@ -95,11 +95,11 @@ JavaScript встановлює деякі інваріанти -- умови, 
 
 Він запускається, коли властивість зчитується, з такими аргументами:
 
-- `target` -- це цільовий об’єкт, який передається як перший аргумент до `new Proxy`,
+- `target` -- це цільовий об'єкт, який передається як перший аргумент до `new Proxy`,
 - `property` -- назва властивості,
-- `receiver` -- якщо цільова властивість є геттером, тоді `receiver` є об’єктом, який буде використовуватися як `this` у його виклику. Зазвичай це сам об’єкт `proxy` (або об’єкт, який успадковується від нього, якщо ми успадковуємо від проксі). Наразі цей аргумент нам не потрібен, тому детальніше роз’яснимо його пізніше.
+- `receiver` -- якщо цільова властивість є геттером, тоді `receiver` є об'єктом, який буде використовуватися як `this` у його виклику. Зазвичай це сам об'єкт `proxy` (або об'єкт, який успадковується від нього, якщо ми успадковуємо від проксі). Наразі цей аргумент нам не потрібен, тому детальніше роз'яснимо його пізніше.
 
-Використаймо `get` для реалізації значень за замовчуванням для об’єкта.
+Використаймо `get` для реалізації значень за замовчуванням для об'єкта.
 
 Ми створимо числовий масив, який повертає `0` для неіснуючих значень.
 
@@ -178,7 +178,7 @@ alert( dictionary['Welcome to Proxy']); // Welcome to Proxy (немає пере
 dictionary = new Proxy(dictionary, ...);
 ```
 
-Проксі повинен повністю замінити цільовий об’єкт скрізь. Ніхто ніколи не повинен посилатися на цільовий об’єкт після того, як він був проксійований. Інакше легко заплутатися.
+Проксі повинен повністю замінити цільовий об'єкт скрізь. Ніхто ніколи не повинен посилатися на цільовий об'єкт після того, як він був проксійований. Інакше легко заплутатися.
 ````
 
 ## Валідація з пасткою "set".
@@ -189,7 +189,7 @@ dictionary = new Proxy(dictionary, ...);
 
 `set(target, property, value, receiver)`:
 
-- `target` -- це цільовий об’єкт, який передається як перший аргумент до `new Proxy`,
+- `target` -- це цільовий об'єкт, який передається як перший аргумент до `new Proxy`,
 - `property` -- назва властивості,
 - `value` -- значення властивості,
 - `receiver` -- аналогічно пастці `get`, має значення лише для властивостей сеттера.
@@ -241,7 +241,7 @@ alert("Цей рядок ніколи не буде досягнуто (поми
 
 ## Перебір за допомогою "ownKeys" і "getOwnPropertyDescriptor"
 
-`Object.keys`, цикл `for..in` та більшість інших методів, які перебирають властивості об’єкта, використовують внутрішній метод `[[OwnPropertyKeys]]` (перехоплюється пасткою `ownKeys`), щоб отримати список властивостей.
+`Object.keys`, цикл `for..in` та більшість інших методів, які перебирають властивості об'єкта, використовують внутрішній метод `[[OwnPropertyKeys]]` (перехоплюється пасткою `ownKeys`), щоб отримати список властивостей.
 
 Такі методи відрізняються в деталях:
 - `Object.getOwnPropertyNames(obj)` повертає несимвольні ключі.
@@ -278,7 +278,7 @@ alert( Object.values(user) ); // Іван,30
 
 Поки що це працює.
 
-Хоча, якщо ми повернемо ключ, якого не існує в об’єкті, `Object.keys` не виведе його в списку:
+Хоча, якщо ми повернемо ключ, якого не існує в об'єкті, `Object.keys` не виведе його в списку:
 
 ```js run
 let user = { };
@@ -296,7 +296,7 @@ alert( Object.keys(user) ); // <пусто>
 
 Чому? Причина проста: `Object.keys` повертає лише властивості з прапором `enumerable`. Щоб перевірити це, він викликає внутрішній метод `[[GetOwnProperty]]` для кожної властивості, щоб отримати [її дескриптор](info:property-descriptors). І тут, оскільки властивості немає, її дескриптор порожній, немає прапора `enumerable`, тому вона пропускається.
 
-Щоб `Object.keys` повертав властивість, нам потрібно, щоб вона існувала в об’єкті з прапором `enumerable`, або ми можемо перехоплювати виклики `[[GetOwnProperty]]` (це робить пастка `getOwnPropertyDescriptor`) , і повертати дескриптор із `enumerable: true`.
+Щоб `Object.keys` повертав властивість, нам потрібно, щоб вона існувала в об'єкті з прапором `enumerable`, або ми можемо перехоплювати виклики `[[GetOwnProperty]]` (це робить пастка `getOwnPropertyDescriptor`) , і повертати дескриптор із `enumerable: true`.
 
 Ось приклад цього:
 
@@ -321,11 +321,11 @@ user = new Proxy(user, {
 alert( Object.keys(user) ); // a, b, c
 ```
 
-Зауважимо ще раз: нам потрібно перехоплювати `[[GetOwnProperty]]` лише тоді, коли властивість відсутня в об’єкті.
+Зауважимо ще раз: нам потрібно перехоплювати `[[GetOwnProperty]]` лише тоді, коли властивість відсутня в об'єкті.
 
 ## Захищені властивості з "deleteProperty" та іншими пастками
 
-Існує поширена домовленість, що властивості та методи з префіксом підкреслення `_` є внутрішніми. До них не слід звертатися ззовні об’єкта.
+Існує поширена домовленість, що властивості та методи з префіксом підкреслення `_` є внутрішніми. До них не слід звертатися ззовні об'єкта.
 
 Але технічно це можливо:
 
@@ -424,26 +424,26 @@ get(target, prop) {
 
 Чому нам потрібна функція для виклику `value.bind(target)`?
 
-Причина в тому, що методи об’єкта, такі як `user.checkPassword()`, повинні мати можливість отримати доступ до `_password`:
+Причина в тому, що методи об'єкта, такі як `user.checkPassword()`, повинні мати можливість отримати доступ до `_password`:
 
 ```js
 user = {
   // ...
   checkPassword(value) {
-    // метод об’єкта повинен мати можливість зчитати _password
+    // метод об'єкта повинен мати можливість зчитати _password
     return value === this._password;
   }
 }
 ```
 
 
-Виклик `user.checkPassword()` отримує проксійований `user` як `this` (об’єкт перед крапкою стає `this`), тому, коли він намагається отримати доступ до `this._password`, активується пастка `get` (вона запускається на будь-якому зчитуванні властивості) і видає помилку.
+Виклик `user.checkPassword()` отримує проксійований `user` як `this` (об'єкт перед крапкою стає `this`), тому, коли він намагається отримати доступ до `this._password`, активується пастка `get` (вона запускається на будь-якому зчитуванні властивості) і видає помилку.
 
-Отже, ми прив’язуємо контекст методів об’єкта до вихідного об’єкта, `target`, у рядку `(*)`. Тоді їхні майбутні виклики використовуватимуть `target` як `this`, без жодних пасток.
+Отже, ми прив'язуємо контекст методів об'єкта до вихідного об'єкта, `target`, у рядку `(*)`. Тоді їхні майбутні виклики використовуватимуть `target` як `this`, без жодних пасток.
 
-Це рішення зазвичай працює, але не є ідеальним, оскільки метод може передати непроксійований об’єкт кудись ще, і тоді ми заплутаємося: де вихідний об’єкт, а де проксійований?
+Це рішення зазвичай працює, але не є ідеальним, оскільки метод може передати непроксійований об'єкт кудись ще, і тоді ми заплутаємося: де вихідний об'єкт, а де проксійований?
 
-Крім того, об’єкт може бути проксійований кілька разів (кілька проксі можуть додавати різні "налаштування" до об’єкта), і якщо ми передаємо розгорнутий об’єкт до методу, можуть виникнути несподівані наслідки.
+Крім того, об'єкт може бути проксійований кілька разів (кілька проксі можуть додавати різні "налаштування" до об'єкта), і якщо ми передаємо розгорнутий об'єкт до методу, можуть виникнути несподівані наслідки.
 
 Отже, такий проксі не варто використовувати всюди.
 
@@ -457,7 +457,7 @@ user = {
 
 Подивімося більше прикладів.
 
-У нас є об’єкт діапазону:
+У нас є об'єкт діапазону:
 
 ```js
 let range = {
@@ -472,7 +472,7 @@ let range = {
 
 `has(target, property)`
 
-- `target` -- це цільовий об’єкт, який передається як перший аргумент до `new Proxy`,
+- `target` -- це цільовий об'єкт, який передається як перший аргумент до `new Proxy`,
 - `property` -- назва властивості
 
 Ось демо:
@@ -505,7 +505,7 @@ alert(50 in range); // false
 
 Пастка `apply(target, thisArg, args)` обробляє виклик проксі як функцію:
 
-- `target` -- це цільовий об’єкт (функція - це об’єкт в JavaScript),
+- `target` -- це цільовий об'єкт (функція - це об'єкт в JavaScript),
 - `thisArg` -- це значенням `this`.
 - `args` -- це список аргументів.
 
@@ -559,7 +559,7 @@ alert(sayHi.length); // 0 (в оголошенні обгортки нуль а
 */!*
 ```
 
-`Proxy` набагато потужніші, оскільки вони перенаправляють все до цільового об’єкта.
+`Proxy` набагато потужніші, оскільки вони перенаправляють все до цільового об'єкта.
 
 Використаймо `Proxy` замість функції-обгортки:
 
@@ -593,11 +593,11 @@ sayHi("John"); // Привіт, Іван! (через 3 секунди)
 
 ## Reflect
 
-`Reflect` -- це вбудований об’єкт, який спрощує створення `Proxy`.
+`Reflect` -- це вбудований об'єкт, який спрощує створення `Proxy`.
 
 Раніше було сказано, що внутрішні методи, такі як `[[Get]]`, `[[Set]]` та інші, призначені лише для специфікації, вони не можуть бути викликані безпосередньо.
 
-Об’єкт `Reflect` робить це певним чином можливим. Його методи -- мінімальні обгортки навколо внутрішніх методів.
+Об'єкт `Reflect` робить це певним чином можливим. Його методи -- мінімальні обгортки навколо внутрішніх методів.
 
 Ось приклади операцій і викликів `Reflect`, які роблять те саме:
 
@@ -623,9 +623,9 @@ alert(user.name); // Іван
 
 **Для кожного внутрішнього методу, перехопленого `Proxy`, є відповідний метод у `Reflect` з тими ж іменами та аргументами, що й пастка `Proxy`.**
 
-Таким чином, ми можемо використовувати `Reflect` для пересилання операції до оригінального об’єкта.
+Таким чином, ми можемо використовувати `Reflect` для пересилання операції до оригінального об'єкта.
 
-У цьому прикладі обидві пастки `get` і `set` прозоро (наче їх не існує) перенаправляють операції зчитування/запису до об’єкта, показуючи повідомлення:
+У цьому прикладі обидві пастки `get` і `set` прозоро (наче їх не існує) перенаправляють операції зчитування/запису до об'єкта, показуючи повідомлення:
 
 ```js run
 let user = {
@@ -653,10 +653,10 @@ user.name = "Петро"; // показує "SET name=Петро"
 
 Тут:
 
-- `Reflect.get` зчитує властивість об’єкта.
-- `Reflect.set` записує властивість об’єкта і повертає `true` у разі успіху, інакше `false`.
+- `Reflect.get` зчитує властивість об'єкта.
+- `Reflect.set` записує властивість об'єкта і повертає `true` у разі успіху, інакше `false`.
 
-Тобто все просто: якщо пастка хоче перенаправити виклик до об’єкта, достатньо викликати `Reflect.<method>` з тими ж аргументами.
+Тобто все просто: якщо пастка хоче перенаправити виклик до об'єкта, достатньо викликати `Reflect.<method>` з тими ж аргументами.
 
 У більшості випадків ми можемо зробити те ж саме без `Reflect`, наприклад, зчитування властивості `Reflect.get(target, prop, receiver)` можна замінити на `target[prop]`. Але є важливі нюанси.
 
@@ -664,7 +664,7 @@ user.name = "Петро"; // показує "SET name=Петро"
 
 Подивімося на приклад, який демонструє, чому `Reflect.get` краще. І ми також побачимо, чому `get/set` має третій аргумент `receiver`, який ми раніше не використовували.
 
-У нас є об’єкт `user` з властивістю `_name` і геттер для нього.
+У нас є об'єкт `user` з властивістю `_name` і геттер для нього.
 
 Ось проксі навколо нього:
 
@@ -691,7 +691,7 @@ alert(userProxy.name); // Гість
 
 Начебто все гаразд. Але зробімо приклад трохи складнішим.
 
-Після успадкування іншого об’єкта `admin` від `user` ми можемо спостерігати неправильну поведінку:
+Після успадкування іншого об'єкта `admin` від `user` ми можемо спостерігати неправильну поведінку:
 
 ```js run
 let user = {
@@ -726,11 +726,11 @@ alert(admin.name); // виводиться: Гість (?!?)
 
 Проблема насправді в проксі, у рядку `(*)`.
 
-1. Коли ми читаємо `admin.name`, оскільки об’єкт `admin` не має такої своєї властивості, пошук переходить до його прототипу.
+1. Коли ми читаємо `admin.name`, оскільки об'єкт `admin` не має такої своєї властивості, пошук переходить до його прототипу.
 2. Прототипом є `userProxy`.
-3. Під час зчитування властивості `name` з проксі спрацьовує пастка `get` і повертає її з вихідного об’єкта як `target[prop]` у рядку `(*)`.
+3. Під час зчитування властивості `name` з проксі спрацьовує пастка `get` і повертає її з вихідного об'єкта як `target[prop]` у рядку `(*)`.
 
-   Виклик `target[prop]`, коли `prop` є геттером, запускає його код у контексті `this=target`. Таким чином, результатом є `this._name` з оригінального об’єкта `target`, тобто: від `user`.
+   Виклик `target[prop]`, коли `prop` є геттером, запускає його код у контексті `this=target`. Таким чином, результатом є `this._name` з оригінального об'єкта `target`, тобто: від `user`.
 
 Щоб виправити такі ситуації, нам потрібен `receiver`, третій аргумент пастки `get`. У ньому зберігається правильний `this` для передачі гетеру. У нашому випадку це `admin`.
 
@@ -780,21 +780,21 @@ get(target, prop, receiver) {
 
 Виклики `Reflect` називаються точно так само, як і пастки, і приймають ті ж самі аргументи. Вони були спеціально розроблені таким чином.
 
-Тож, `return Reflect...` забезпечує безпечну та просту переадресацію операції та оберігає від того, що ми забудемо щось, що пов’язане з цим.
+Тож, `return Reflect...` забезпечує безпечну та просту переадресацію операції та оберігає від того, що ми забудемо щось, що пов'язане з цим.
 
 ## Обмеження проксі
 
-Проксі надають унікальний спосіб змінити або налаштувати поведінку існуючих об’єктів на найнижчому рівні. Все-таки це не ідеально. Існують обмеження.
+Проксі надають унікальний спосіб змінити або налаштувати поведінку існуючих об'єктів на найнижчому рівні. Все-таки це не ідеально. Існують обмеження.
 
-### Вбудовані об’єкти: внутрішні слоти
+### Вбудовані об'єкти: внутрішні слоти
 
-Багато вбудованих об’єктів, наприклад `Map`, `Set`, `Date`, `Promise` та інші, використовують так звані "внутрішні слоти".
+Багато вбудованих об'єктів, наприклад `Map`, `Set`, `Date`, `Promise` та інші, використовують так звані "внутрішні слоти".
 
 Це подібні властивості, але зарезервовані для внутрішніх цілей, призначених лише для специфікації. Наприклад, `Map` зберігає елементи у внутрішньому слоті `[[MapData]]`. Вбудовані методи отримують доступ до них безпосередньо, а не через внутрішні методи `[[Get]]/[[Set]]`. Тому `Proxy` не може перехопити це.
 
 Чому це має значення? Вони ж все одно внутрішні!
 
-Ну, є одна проблема. Після того, як такий вбудований об’єкт проксіюється, проксі не має цих внутрішніх слотів, тому виклики вбудованих методів призведуть до помилок.
+Ну, є одна проблема. Після того, як такий вбудований об'єкт проксіюється, проксі не має цих внутрішніх слотів, тому виклики вбудованих методів призведуть до помилок.
 
 Наприклад:
 
@@ -828,12 +828,12 @@ proxy.set('test', 1);
 alert(proxy.get('test')); // 1 (працює!)
 ```
 
-Тепер все працює нормально, тому що пастка `get` пов’язує властивості функції, такі як `map.set`, із самим цільовим об’єктом (`map`).
+Тепер все працює нормально, тому що пастка `get` пов'язує властивості функції, такі як `map.set`, із самим цільовим об'єктом (`map`).
 
 На відміну від попереднього прикладу, значення `this` всередині `proxy.set(...)` буде не `proxy`, а оригінальним `map`. Тому, коли внутрішня реалізація `set` намагатиметься отримати доступ до `this.[[MapData]]` внутрішнього слота, операція завершиться успішно.
 
 ```smart header="`Array` не має внутрішніх слотів"
-Помітний виняток: вбудований `Array` не використовує внутрішні слоти. Так склалося з історичних причин, оскільки масиви з’явилися дуже давно.
+Помітний виняток: вбудований `Array` не використовує внутрішні слоти. Так склалося з історичних причин, оскільки масиви з'явилися дуже давно.
 
 Саме тому вищевказана проблема не виникає при проксіюванні масиву.
 ```
@@ -866,7 +866,7 @@ alert(user.getName()); // Помилка
 
 У виклику `getName()` значенням `this` є проксійований `user`, і він не має слота з приватними полями.
 
-Знову ж таки, рішення з прив’язкою методу змушує його працювати:
+Знову ж таки, рішення з прив'язкою методу змушує його працювати:
 
 ```js run
 class User {
@@ -889,13 +889,13 @@ user = new Proxy(user, {
 alert(user.getName()); // Гість
 ```
 
-Проте це рішення має недоліки, як пояснювалося раніше: воно відкриває вихідний об’єкт методу, потенційно дозволяючи його передавати далі та порушуючи інші функціональні можливості проксі.
+Проте це рішення має недоліки, як пояснювалося раніше: воно відкриває вихідний об'єкт методу, потенційно дозволяючи його передавати далі та порушуючи інші функціональні можливості проксі.
 
-### Проксі != цільовий об’єкт
+### Проксі != цільовий об'єкт
 
-Проксі та оригінальний об’єкт – це різні об’єкти. Це природно, правда?
+Проксі та оригінальний об'єкт – це різні об'єкти. Це природно, правда?
 
-Отже, якщо ми використовуємо оригінальний об’єкт як ключ, а потім проксіюємо його, то проксі не буде знайдено:
+Отже, якщо ми використовуємо оригінальний об'єкт як ключ, а потім проксіюємо його, то проксі не буде знайдено:
 
 ```js run
 let allUsers = new Set();
@@ -918,14 +918,14 @@ alert(allUsers.has(user)); // false
 */!*
 ```
 
-Як бачимо, після проксіювання ми не можемо знайти `user` у наборі `allUsers`, оскільки проксі є іншим об’єктом.
+Як бачимо, після проксіювання ми не можемо знайти `user` у наборі `allUsers`, оскільки проксі є іншим об'єктом.
 
 ```warn header="Проксі не можуть перехопити перевірку на сувору рівність `===`"
 Проксі можуть перехоплювати багато операторів, таких як `new` (з `construct`), `in` (з `has`), `delete` (з `deleteProperty`) тощо.
 
-Але немає способу перехопити перевірку на сувору рівність для об’єктів. Об’єкт суворо рівний тільки самому собі, і жодному іншому значенню.
+Але немає способу перехопити перевірку на сувору рівність для об'єктів. Об'єкт суворо рівний тільки самому собі, і жодному іншому значенню.
 
-Таким чином, усі операції та вбудовані класи, які порівнюють об’єкти на рівність, відрізнятимуть об’єкт від проксі. Тут немає прозорої заміни.
+Таким чином, усі операції та вбудовані класи, які порівнюють об'єкти на рівність, відрізнятимуть об'єкт від проксі. Тут немає прозорої заміни.
 ```
 
 ## Проксі, що відкликаються
@@ -934,7 +934,7 @@ alert(allUsers.has(user)); // false
 
 Скажімо, у нас є ресурс, і ми хочемо закрити доступ до нього в будь-який момент.
 
-Що ми можемо зробити, так це обгорнути його у проксі, що відкликається, без будь-яких пасток. Такий проксі буде пересилати операції на об’єкт, і ми можемо вимкнути його в будь-який момент.
+Що ми можемо зробити, так це обгорнути його у проксі, що відкликається, без будь-яких пасток. Такий проксі буде пересилати операції на об'єкт, і ми можемо вимкнути його в будь-який момент.
 
 Синтаксис такий:
 
@@ -942,7 +942,7 @@ alert(allUsers.has(user)); // false
 let {proxy, revoke} = Proxy.revocable(target, handler)
 ```
 
-Виклик повертає об’єкт із функціями `proxy` та `revoke`, щоб вимкнути його.
+Виклик повертає об'єкт із функціями `proxy` та `revoke`, щоб вимкнути його.
 
 Ось приклад:
 
@@ -953,7 +953,7 @@ let object = {
 
 let {proxy, revoke} = Proxy.revocable(object, {});
 
-// передати проксі десь замість об’єкта...
+// передати проксі десь замість об'єкта...
 alert(proxy.data); // Важливі дані
 
 // пізніше в нашому коді
@@ -963,11 +963,11 @@ revoke();
 alert(proxy.data); // Помилка
 ```
 
-Виклик `revoke()` видаляє всі внутрішні посилання на цільовий об’єкт із проксі, тому вони більше не пов’язані.
+Виклик `revoke()` видаляє всі внутрішні посилання на цільовий об'єкт із проксі, тому вони більше не пов'язані.
 
 Спочатку `revoke` існує окремо від `proxy`, тому ми можемо передавати `proxy` скрізь, залишаючи `revoke` у поточній області.
 
-Ми також можемо прив’язати метод `revoke` до проксі, встановивши `proxy.revoke = revoke`.
+Ми також можемо прив'язати метод `revoke` до проксі, встановивши `proxy.revoke = revoke`.
 
 Інший варіант -- створити `WeakMap`, який має `proxy` як ключ і відповідне значення `revoke` як значення, що дозволяє легко знайти `revoke` для проксі:
 
@@ -991,7 +991,7 @@ revoke();
 alert(proxy.data); // Помилка (відкликано)
 ```
 
-Тут ми використовуємо `WeakMap` замість `Map`, оскільки він не блокує збір сміття. Якщо об’єкт проксі стає "недоступним" (наприклад, жодна змінна більше не посилається на нього), `WeakMap` дозволяє стерти його з пам’яті разом із його `revoke`, що нам більше не знадобиться.
+Тут ми використовуємо `WeakMap` замість `Map`, оскільки він не блокує збір сміття. Якщо об'єкт проксі стає "недоступним" (наприклад, жодна змінна більше не посилається на нього), `WeakMap` дозволяє стерти його з пам'яті разом із його `revoke`, що нам більше не знадобиться.
 
 ## Посилання
 
@@ -1000,9 +1000,9 @@ alert(proxy.data); // Помилка (відкликано)
 
 ## Підсумки
 
-`Проксі` -- це обгортка навколо об’єкта, яка перенаправляє операції над нею до об’єкта, маючи можливість перехоплювати деякі з них.
+`Проксі` -- це обгортка навколо об'єкта, яка перенаправляє операції над нею до об'єкта, маючи можливість перехоплювати деякі з них.
 
-Проксіювати можна будь-який тип об’єкта, включаючи класи та функції.
+Проксіювати можна будь-який тип об'єкта, включаючи класи та функції.
 
 Синтаксис такий:
 
@@ -1012,7 +1012,7 @@ let proxy = new Proxy(target, {
 });
 ```
 
-...Тоді ми повинні використовувати `proxy` скрізь замість `target`. Проксі не має своїх властивостей чи методів. Він перехоплює операцію, якщо пастка передбачена, в іншому випадку пересилає її до цільового об’єкта.
+...Тоді ми повинні використовувати `proxy` скрізь замість `target`. Проксі не має своїх властивостей чи методів. Він перехоплює операцію, якщо пастка передбачена, в іншому випадку пересилає її до цільового об'єкта.
 
 Ми можемо захопити:
 - Зчитування (`get`), запис (`set`), видалення (`deleteProperty`) властивості (навіть неіснуючої).
@@ -1020,15 +1020,15 @@ let proxy = new Proxy(target, {
 - Оператор `new` (пастка `construct`).
 - Багато інших операцій (повний список на початку статті та в [документації](mdn:/JavaScript/Reference/Global_Objects/Proxy)).
 
-Це дозволяє нам створювати "віртуальні" властивості та методи, реалізовувати значення за замовчуванням, спостережувані об’єкти, декоратори функцій та багато іншого.
+Це дозволяє нам створювати "віртуальні" властивості та методи, реалізовувати значення за замовчуванням, спостережувані об'єкти, декоратори функцій та багато іншого.
 
-Ми також можемо обгорнути об’єкт кілька разів у різні проксі, прикрашаючи його різними аспектами функціональності.
+Ми також можемо обгорнути об'єкт кілька разів у різні проксі, прикрашаючи його різними аспектами функціональності.
 
-[Reflect](mdn:/JavaScript/Reference/Global_Objects/Reflect) API розроблено для доповнення [Proxy](mdn:/JavaScript/Reference/Global_Objects/Proxy). Для будь-якої пастки `Proxy` є виклик `Reflect` з тими самими аргументами. Ми повинні використовувати їх для переадресації викликів цільовим об’єктам.
+[Reflect](mdn:/JavaScript/Reference/Global_Objects/Reflect) API розроблено для доповнення [Proxy](mdn:/JavaScript/Reference/Global_Objects/Proxy). Для будь-якої пастки `Proxy` є виклик `Reflect` з тими самими аргументами. Ми повинні використовувати їх для переадресації викликів цільовим об'єктам.
 
 Проксі мають деякі обмеження:
 
-- Вбудовані об’єкти мають "внутрішні слоти", доступ до них не може бути проксійованим. Перегляньте обхідний шлях вище.
-- Те ж саме стосується полів приватного класу, оскільки вони внутрішньо реалізовані за допомогою слотів. Тому виклики методів через проксі повинні мати цільовий об’єкт як `this` для доступу до них.
-- Перевірки об’єктів на сувору рівність `===` не можуть бути перехоплені.
-- Продуктивність: контрольні показники залежать від інтерпретатора, але зазвичай доступ до властивості за допомогою найпростішого проксі займає в кілька разів більше часу. На практиці це має значення лише для деяких "особливо навантажених" об’єктів.
\ No newline at end of file
+- Вбудовані об'єкти мають "внутрішні слоти", доступ до них не може бути проксійованим. Перегляньте обхідний шлях вище.
+- Те ж саме стосується полів приватного класу, оскільки вони внутрішньо реалізовані за допомогою слотів. Тому виклики методів через проксі повинні мати цільовий об'єкт як `this` для доступу до них.
+- Перевірки об'єктів на сувору рівність `===` не можуть бути перехоплені.
+- Продуктивність: контрольні показники залежать від інтерпретатора, але зазвичай доступ до властивості за допомогою найпростішого проксі займає в кілька разів більше часу. На практиці це має значення лише для деяких "особливо навантажених" об'єктів.
\ No newline at end of file
diff --git a/1-js/99-js-misc/03-currying-partials/article.md b/1-js/99-js-misc/03-currying-partials/article.md
index acd781a74..2ad891cbe 100644
--- a/1-js/99-js-misc/03-currying-partials/article.md
+++ b/1-js/99-js-misc/03-currying-partials/article.md
@@ -173,8 +173,8 @@ function curried(...args) {
 
 Для виклику `curried(1)(2)(3)`:
 
-1. Перший виклик `curried(1)` запам’ятовує `1` у своєму лексичному середовищі і повертає обгортку `pass`.
-2. Обгортка `pass` викликається з `(2)`: вона бере попередні аргументи (`1`), об’єднує їх з тим, що отримала сама `(2)` і викликає `curried(1, 2)` з усіма аргументами. Оскільки число аргументів все ще менше за `3`, `curry` повертає `pass`.
+1. Перший виклик `curried(1)` запам'ятовує `1` у своєму лексичному середовищі і повертає обгортку `pass`.
+2. Обгортка `pass` викликається з `(2)`: вона бере попередні аргументи (`1`), об'єднує їх з тим, що отримала сама `(2)` і викликає `curried(1, 2)` з усіма аргументами. Оскільки число аргументів все ще менше за `3`, `curry` повертає `pass`.
 3. Обгортка `pass` викликається знову з `(3)`. Для наступного виклику `pass(3)` бере попередні аргументи `(1, 2)` і додає до них `3`, викликаючи `curried(1, 2, 3)` - нарешті 3 аргументи, і вони передаються оригінальній функції.
 
 Якщо все ще не зрозуміло, просто розпишіть послідовність викликів на папері.
diff --git a/1-js/99-js-misc/04-reference-type/article.md b/1-js/99-js-misc/04-reference-type/article.md
index 1c0041267..a2621e1bd 100644
--- a/1-js/99-js-misc/04-reference-type/article.md
+++ b/1-js/99-js-misc/04-reference-type/article.md
@@ -32,7 +32,7 @@ user.hi(); // працює
 
 Як ви бачите, виклик призводить до помилки, тому що значення `"this"` всередині виклику стає `undefined`.
 
-Це працює (метод об’єкта через крапку):
+Це працює (метод об'єкта через крапку):
 ```js
 user.hi();
 ```
@@ -76,7 +76,7 @@ hi(); // Помилка, тому що this -- це undefined
 
 Значення посилального типу -- це комбінація трьох значення `(base, name, strict)`, де:
 
-- `base` -- це об’єкт.
+- `base` -- це об'єкт.
 - `name` -- це назва властивості.
 - `strict` -- це true якщо діє `use strict`.
 
@@ -87,22 +87,22 @@ hi(); // Помилка, тому що this -- це undefined
 (user, "hi", true)
 ```
 
-Коли дужки `()` викликаються з посилальним типом, вони отримують повну інформацію про об’єкт та його метод, і можуть встановити правильний `this` (`user` у даному випадку).
+Коли дужки `()` викликаються з посилальним типом, вони отримують повну інформацію про об'єкт та його метод, і можуть встановити правильний `this` (`user` у даному випадку).
 
 Посилальний тип -- це особливий "посередницький" внутрішній тип, який використовується з метою передачі інформації від крапки `.` до дужок виклику `()`.
 
 Будь-яка інша операція, наприклад присвоєння `hi = user.hi` в цілому відкидає посилальний тип та приймає значення `user.hi` (функції) і передає його. Отже, будь-яка подальша операція "втрачає" `this`.
 
-Отже, як результат, значення `this` передається правильно тільки тоді, якщо функція викликається безпосередньо за допомогою крапки `obj.method()` або синтаксису квадратних дужок `obj['method']()` (вони роблять одне й те ж саме). Існують різні способи розв’язання цієї проблеми, як [func.bind()](/bind#solution-2-bind).
+Отже, як результат, значення `this` передається правильно тільки тоді, якщо функція викликається безпосередньо за допомогою крапки `obj.method()` або синтаксису квадратних дужок `obj['method']()` (вони роблять одне й те ж саме). Існують різні способи розв'язання цієї проблеми, як [func.bind()](/bind#solution-2-bind).
 
 ## Підсумки
 
 Посилальний тип -- це внутрішній тип мови.
 
-Читання властивості, наприклад, крапкою `.` в `obj.method()` повертає не саме значення властивості, але спеціальне значення "посилального типу", яке зберігає як значення властивості, так і об’єкт, з якою він був взятий.
+Читання властивості, наприклад, крапкою `.` в `obj.method()` повертає не саме значення властивості, але спеціальне значення "посилального типу", яке зберігає як значення властивості, так і об'єкт, з якою він був взятий.
 
-Це використовується для подальшого виклику методу за допомогою `()`, щоб отримати об’єкт і встановити `this` до цього.
+Це використовується для подальшого виклику методу за допомогою `()`, щоб отримати об'єкт і встановити `this` до цього.
 
 Для всіх інших операцій, посилальний тип автоматично стає значенням властивості (функцією у нашому випадку).
 
-Вся ця механіка прихована від наших очей. Це лише важливо в тонких випадках, наприклад, коли метод отримується динамічно з об’єкта, використовуючи вираз.
+Вся ця механіка прихована від наших очей. Це лише важливо в тонких випадках, наприклад, коли метод отримується динамічно з об'єкта, використовуючи вираз.
diff --git a/1-js/99-js-misc/06-unicode/article.md b/1-js/99-js-misc/06-unicode/article.md
index b07f178da..b1f351d80 100644
--- a/1-js/99-js-misc/06-unicode/article.md
+++ b/1-js/99-js-misc/06-unicode/article.md
@@ -109,7 +109,7 @@ alert( 'Привіт 😂'.slice(0, 8) ); // Привіт [?]
 
 Тут ми можемо побачити незрозумілий символ (першу половину сурогатної пари посмішки) у виведених даних.
 
-Просто пам’ятайте про це, якщо ви хочете надійно працювати із сурогатними парами. Можливо, це не велика проблема, але принаймні ви повинні розуміти, що відбувається.
+Просто пам'ятайте про це, якщо ви хочете надійно працювати із сурогатними парами. Можливо, це не велика проблема, але принаймні ви повинні розуміти, що відбувається.
 ````
 
 ## Діакритичні знаки та нормалізація
@@ -159,7 +159,7 @@ alert( s1 == s2 ); // false, хоча символи виглядають одн
 alert( "S\u0307\u0323".normalize() == "S\u0323\u0307".normalize() ); // true
 ```
 
-Цікаво, що в нашій ситуації `normalize()` фактично об’єднує послідовність із 3 символів в один: `\u1e68` (S з двома крапками).
+Цікаво, що в нашій ситуації `normalize()` фактично об'єднує послідовність із 3 символів в один: `\u1e68` (S з двома крапками).
 
 ```js run
 alert( "S\u0307\u0323".normalize().length ); // 1

From 87931ef9dc47f493acdae631d402b9eaf4eaeed7 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:26 +0300
Subject: [PATCH 02/11] =?UTF-8?q?feat(2-ui):=20Changed=20all=20apostrophes?=
 =?UTF-8?q?=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../01-browser-environment/article.md         | 36 ++++++------
 2-ui/1-document/02-dom-nodes/article.md       | 12 ++--
 2-ui/1-document/03-dom-navigation/article.md  | 10 ++--
 .../04-searching-elements-dom/article.md      | 10 ++--
 .../3-tag-in-comment/solution.md              |  2 +-
 .../4-where-document-in-hierarchy/solution.md |  4 +-
 .../05-basic-dom-node-properties/article.md   | 20 +++----
 .../article.md                                | 16 +++---
 .../10-clock-setinterval/solution.md          |  2 +-
 .../12-sort-table/solution.md                 |  2 +-
 .../12-sort-table/task.md                     |  2 +-
 .../7-create-object-tree/solution.md          |  2 +-
 .../7-create-object-tree/task.md              |  4 +-
 .../9-calendar-table/solution.md              |  2 +-
 .../07-modifying-document/article.md          |  4 +-
 .../08-styles-and-classes/article.md          | 20 +++----
 2-ui/1-document/09-size-and-scroll/article.md |  2 +-
 .../10-size-and-scroll-window/article.md      |  6 +-
 .../1-find-point-coordinates/task.md          |  2 +-
 .../3-position-at-absolute/task.md            |  2 +-
 .../4-position-inside-absolute/task.md        |  2 +-
 2-ui/1-document/11-coordinates/article.md     | 20 +++----
 .../04-move-ball-field/solution.md            | 16 +++---
 .../04-move-ball-field/task.md                | 12 ++--
 .../01-introduction-browser-events/article.md | 32 +++++------
 .../02-bubbling-and-capturing/article.md      |  4 +-
 .../3-sortable-table/task.md                  |  2 +-
 .../4-behavior-tooltip/task.md                |  2 +-
 2-ui/2-events/03-event-delegation/article.md  | 12 ++--
 .../04-default-browser-action/article.md      | 16 +++---
 2-ui/2-events/05-dispatch-events/article.md   | 16 +++---
 .../1-mouse-events-basics/article.md          |  2 +-
 .../2-drag-heroes/task.md                     |  2 +-
 .../4-mouse-drag-and-drop/article.md          | 56 +++++++++----------
 .../6-pointer-events/article.md               | 26 ++++-----
 .../7-keyboard-events/article.md              | 12 ++--
 .../8-onscroll/2-updown-button/task.md        |  2 +-
 .../8-onscroll/3-load-visible-img/task.md     |  2 +-
 .../1-form-elements/article.md                | 14 ++---
 .../2-focus-blur/3-editable-div/task.md       |  2 +-
 .../2-focus-blur/4-edit-td-click/task.md      |  4 +-
 2-ui/4-forms-controls/2-focus-blur/article.md |  4 +-
 .../4-forms-submit/article.md                 |  4 +-
 .../01-onload-ondomcontentloaded/article.md   | 16 +++---
 .../02-script-async-defer/article.md          |  6 +-
 .../1-load-img-callback/task.md               |  2 +-
 .../2-micro-macro-queue/solution.md           |  4 +-
 2-ui/99-ui-misc/03-event-loop/article.md      | 18 +++---
 48 files changed, 235 insertions(+), 235 deletions(-)

diff --git a/2-ui/1-document/01-browser-environment/article.md b/2-ui/1-document/01-browser-environment/article.md
index 48cce1cc9..83afc5b6c 100644
--- a/2-ui/1-document/01-browser-environment/article.md
+++ b/2-ui/1-document/01-browser-environment/article.md
@@ -4,25 +4,25 @@
 
 Платформою може бути браузер, або вебсервер або інший *хост*, навіть "розумна" кавоварка, якщо вона може запустити JavaScript. Кожна з них забезпечує специфічну для платформи функціональність. Специфікація JavaScript називає це *середовищем*.
 
-Середовище надає власні об’єкти та додаткові функції до базової мови. Веббраузери дають засоби для керування вебсторінками. Node.js забезпечує функції сервера тощо.
+Середовище надає власні об'єкти та додаткові функції до базової мови. Веббраузери дають засоби для керування вебсторінками. Node.js забезпечує функції сервера тощо.
 
 На рисунку нижче показано в загальних рисах те, що ми маємо, коли JavaScript працює в веббраузері:
 
 ![](windowObjects.svg)
 
-Є "корінний" об’єкт, що називається `window`. Він має дві ролі:
+Є "корінний" об'єкт, що називається `window`. Він має дві ролі:
 
-1. По-перше, це глобальний об’єкт для коду JavaScript, як описано в розділі <info:global-object>.
+1. По-перше, це глобальний об'єкт для коду JavaScript, як описано в розділі <info:global-object>.
 2. По-друге, він являє собою "вікно браузера" та надає способи для керування ним.
 
-Наприклад, тут ми використовуємо його як глобальний об’єкт:
+Наприклад, тут ми використовуємо його як глобальний об'єкт:
 
 ```js run
 function sayHi() {
   alert("Привіт");
 }
 
-// глобальні функції є методами глобального об’єкта:
+// глобальні функції є методами глобального об'єкта:
 window.sayHi();
 ```
 
@@ -36,9 +36,9 @@ alert(window.innerHeight); // внутрішня висота вікна
 
 ## DOM (Document Object Model)
 
-Document Object Model, або скорочено DOM -- представляє весь контент сторінки як об’єкти, які можуть бути змінені.
+Document Object Model, або скорочено DOM -- представляє весь контент сторінки як об'єкти, які можуть бути змінені.
 
-Об’єкт `document` -- це головна "точка входу" до сторінки. Ми можемо змінити або створити що-небудь на сторінці, використовуючи цей об’єкт.
+Об'єкт `document` -- це головна "точка входу" до сторінки. Ми можемо змінити або створити що-небудь на сторінці, використовуючи цей об'єкт.
 
 Наприклад
 ```js run
@@ -52,27 +52,27 @@ setTimeout(() => document.body.style.background = "", 1000);
 Тут ми використовували `document.body.style`, але там набагато, набагато більше властивостей. Властивості та методи описані у специфікації: [DOM Living Standard](https://dom.spec.whatwg.org).
 
 ```smart header="DOM -- не лише для браузерів"
-Специфікація DOM описує структуру документа та надає об’єкти, щоб керувати ним. Є також інші інструменти окрім браузерів, які також використовують DOM.
+Специфікація DOM описує структуру документа та надає об'єкти, щоб керувати ним. Є також інші інструменти окрім браузерів, які також використовують DOM.
 
 Наприклад, скрипти сервера, які завантажують HTML-сторінки та обробляють їх також можуть використовувати DOM. При цьому вони можуть підтримувати лише частину специфікації.
 ```
 
 ```smart header="CSSOM для стилю"
-Також є окрема специфікація, [CSS Object Model (CSSOM)](https://www.w3.org/TR/cssom-1/) для правил CSS та таблиць стилів, що пояснює, як стилі повинні бути представлені у вигляді об’єктів, як читати та писати їх.
+Також є окрема специфікація, [CSS Object Model (CSSOM)](https://www.w3.org/TR/cssom-1/) для правил CSS та таблиць стилів, що пояснює, як стилі повинні бути представлені у вигляді об'єктів, як читати та писати їх.
 
 CSSOM використовується разом з DOM, коли ми змінюємо правила стилів для документа. Хоча на практиці, ми рідко використовуємо CSSOM, тому що рідко змінюємо CSS-правила через JavaScript (зазвичай ми просто додаємо/видаляємо CSS-класи, не змінюючи їх CSS-правила), але це також можливо.
 ```
 
 ## BOM (Browser Object Model)
 
-Модель об’єкта браузера (Browser Object Model, BOM) -- це додаткові об’єкти, надані браузером (хост-середовищем) для роботи з усім, крім документа.
+Модель об'єкта браузера (Browser Object Model, BOM) -- це додаткові об'єкти, надані браузером (хост-середовищем) для роботи з усім, крім документа.
 
 Наприклад:
 
-- Об’єкт [navigator](mdn:api/Window/navigator) забезпечує інформацію про браузер та операційну систему. Існує багато його властивостей, але два найбільш широко відомих: `navigator.userAgent` -- інформація про поточний браузер, та `navigator.platform` -- про платформу (може допомогти визначити на якій платформі відкрито браузер -- Windows/Linux/Mac тощо).
-- Об’єкт [location](mdn:api/Window/location) дозволяє нам прочитати поточну URL-адресу і може перенаправити веббраузер на нову адресу.
+- Об'єкт [navigator](mdn:api/Window/navigator) забезпечує інформацію про браузер та операційну систему. Існує багато його властивостей, але два найбільш широко відомих: `navigator.userAgent` -- інформація про поточний браузер, та `navigator.platform` -- про платформу (може допомогти визначити на якій платформі відкрито браузер -- Windows/Linux/Mac тощо).
+- Об'єкт [location](mdn:api/Window/location) дозволяє нам прочитати поточну URL-адресу і може перенаправити веббраузер на нову адресу.
 
-Ось як ми можемо використовувати об’єкт `location`:
+Ось як ми можемо використовувати об'єкт `location`:
 
 ```js run
 alert(location.href); // показує поточний URL-адрес
@@ -81,12 +81,12 @@ if (confirm("Перейти на сайт Wikipedia?")) {
 }
 ```
 
-Функції `alert/confirm/prompt` також є частиною BOM: вони безпосередньо не пов’язані з документом, але являють собою чисті методи взаємодії з користувачем.
+Функції `alert/confirm/prompt` також є частиною BOM: вони безпосередньо не пов'язані з документом, але являють собою чисті методи взаємодії з користувачем.
 
 ```smart header="Специфікації"
 BOM -- це частина загальної [HTML-специфікації](https://html.spec.whatwg.org).
 
-Так, ви правильно почули. Специфікація HTML на <https://html.spec.whatwg.org> -- це не тільки про "мову HTML" (теги, атрибути). Вона також охоплює купу об’єктів, методів та специфічних для браузера розширень DOM. Це "HTML в широкому сенсі". Крім того, деякі частини мають додаткові специфікації, перераховані на <https://spec.whatwg.org>.
+Так, ви правильно почули. Специфікація HTML на <https://html.spec.whatwg.org> -- це не тільки про "мову HTML" (теги, атрибути). Вона також охоплює купу об'єктів, методів та специфічних для браузера розширень DOM. Це "HTML в широкому сенсі". Крім того, деякі частини мають додаткові специфікації, перераховані на <https://spec.whatwg.org>.
 ```
 
 ## Підсумки
@@ -97,14 +97,14 @@ BOM -- це частина загальної [HTML-специфікації](ht
 : Описує структуру документа, маніпуляції та події, див. <https://dom.spec.whatwg.org>.
 
 Специфікацію CSSOM
-: Описує таблиці стилів і правила стилів, маніпуляції з ними і їх зв’язування з документами, див. <https://www.w3.org/TR/cssom-1/>.
+: Описує таблиці стилів і правила стилів, маніпуляції з ними і їх зв'язування з документами, див. <https://www.w3.org/TR/cssom-1/>.
 
 Специфікацію HTML
-: Описує мову HTML (наприклад, теги), а також BOM (модель об’єкта браузера) -- різні функції браузера: `setTimeout`, `alert`, `location` і так далі, див. <https://html.spec.whatwg.org>. Вона приймає специфікацію DOM та розширює її багатьма додатковими властивостями та методами.
+: Описує мову HTML (наприклад, теги), а також BOM (модель об'єкта браузера) -- різні функції браузера: `setTimeout`, `alert`, `location` і так далі, див. <https://html.spec.whatwg.org>. Вона приймає специфікацію DOM та розширює її багатьма додатковими властивостями та методами.
 
 Крім того, деякі класи описуються окремо на <https://spec.whatwg.org/>.
 
-Буль ласка, збережіть ці посилання, оскільки у них подано багато цікавої інформації для вивчення, яку неможливо цілком розглянути і все запам’ятати.
+Буль ласка, збережіть ці посилання, оскільки у них подано багато цікавої інформації для вивчення, яку неможливо цілком розглянути і все запам'ятати.
 
 Коли ви хочете прочитати про властивість або метод, посібник Mozilla за адресою <https://developer.mozilla.org/en-US/> також є хорошим ресурсом, але відповідна специфікація може бути навіть кращим ресурсом: вона складніша і її довше читати, але вона зробить ваші знання фундаментальними та повними.
 
diff --git a/2-ui/1-document/02-dom-nodes/article.md b/2-ui/1-document/02-dom-nodes/article.md
index 842840850..454cca040 100644
--- a/2-ui/1-document/02-dom-nodes/article.md
+++ b/2-ui/1-document/02-dom-nodes/article.md
@@ -8,11 +8,11 @@ libs:
 
 Основою HTML-документа є теги.
 
-Відповідно до об’єктної моделі документа ("Document Object Model", DOM), кожен HTML-тег є об’єктом. Вкладені теги є "дітьми" батьківського елементу. Текст, який знаходиться всередині тегу, також є об’єктом.
+Відповідно до об'єктної моделі документа ("Document Object Model", DOM), кожен HTML-тег є об'єктом. Вкладені теги є "дітьми" батьківського елементу. Текст, який знаходиться всередині тегу, також є об'єктом.
 
-Всі ці об’єкти доступні за допомогою JavaScript, і ми можемо використовувати їх для зміни сторінки.
+Всі ці об'єкти доступні за допомогою JavaScript, і ми можемо використовувати їх для зміни сторінки.
 
-Наприклад, `document.body` це об’єкт, що представляє тег `<body>`.
+Наприклад, `document.body` це об'єкт, що представляє тег `<body>`.
 
 Запуск цього коду зробить `<body>` червоним протягом 3 секунд:
 
@@ -60,7 +60,7 @@ drawHtmlTree(node1, 'div.domtree', 690, 320);
 На зображенні вище, ви можете натиснути на вузли-елементи, а їхні діти будуть відкриватися і закриватися.
 ```
 
-Кожен вузол дерева є об’єктом.
+Кожен вузол дерева є об'єктом.
 
 Теги є *вузлами-елементами* (або просто елементами), вони утворюють структуру дерева: `<html>` -- кореневий, `<head>` та `<body>` -- його дочірні вузли тощо.
 
@@ -160,7 +160,7 @@ let node5 = {"name":"TABLE","nodeType":1,"children":[{"name":"TBODY","nodeType":
 drawHtmlTree(node5,  'div.domtree', 600, 200);
 </script>
 
-Бачите? Тег `<tbody>` з’явився з нізвідки. Ми повинні мати це на увазі під час роботи з таблицями, щоб уникати сюрпризів.
+Бачите? Тег `<tbody>` з'явився з нізвідки. Ми повинні мати це на увазі під час роботи з таблицями, щоб уникати сюрпризів.
 ````
 
 ## Інші типи вузлів
@@ -201,7 +201,7 @@ drawHtmlTree(node6, 'div.domtree', 690, 500);
 
 Навіть директива `<!DOCTYPE...>` на самому початку HTML також є вузлом DOM. Вона є DOM дереві прямо перед `<html>`. Мало хто знає про це. Ми не збираємося звертатися до цього вузла, ми навіть не малюємо його на діаграмах, але він там є.
 
-Об’єкт `document`, який представляє весь документ, формально також є вузлом DOM.
+Об'єкт `document`, який представляє весь документ, формально також є вузлом DOM.
 
 Існує [12 типів вузлів](https://dom.spec.whatwg.org/#node). На практиці ми зазвичай працюємо з 4-ма з них:
 
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index b665a1208..8682b4092 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -7,9 +7,9 @@ libs:
 
 # Навігація по DOM
 
-DOM дозволяє нам робити будь-що з елементами та їх вмістом, але спочатку нам потрібно отримати відповідний DOM об’єкт.
+DOM дозволяє нам робити будь-що з елементами та їх вмістом, але спочатку нам потрібно отримати відповідний DOM об'єкт.
 
-Усі операції з DOM починаються з об’єкта `document`. Це головна "точка входу" в DOM. З нього ми можемо отримати доступ до будь-якого вузла.
+Усі операції з DOM починаються з об'єкта `document`. Це головна "точка входу" в DOM. З нього ми можемо отримати доступ до будь-якого вузла.
 
 Ось так виглядають основні посилання, які дозволяють переміщатися між вузлами DOM:
 
@@ -129,7 +129,7 @@ elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
 
 ### DOM колекції
 
-Як бачимо, `childNodes` виглядає як масив. Але насправді це не масив, а скоріше *колекція* -- спеціальний ітеративний об’єкт-псевдомасив.
+Як бачимо, `childNodes` виглядає як масив. Але насправді це не масив, а скоріше *колекція* -- спеціальний ітеративний об'єкт-псевдомасив.
 
 Є два важливих наслідки з цього:
 
@@ -139,7 +139,7 @@ elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
     alert(node); // показує всі вузли з колекції
   }
   ```
-  Це працює, бо колекція є ітерованим об’єктом (є потрібний для цього метод `Symbol.iterator`).
+  Це працює, бо колекція є ітерованим об'єктом (є потрібний для цього метод `Symbol.iterator`).
 
 2. Методи масиву не працюватимуть, бо колекція це не масив:
   ```js run
@@ -163,7 +163,7 @@ elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
 ```warn header="DOM колецкції живі"
 Майже всі колекції DOM, за незначними винятками, є *живими*. Іншими словами, вони завжди відображають поточний стан DOM.
 
-Якщо ми зберегли посилання на `elem.childNodes` і після цього додамо/видалимо вузли в DOM, вони автоматично з’являться в колекції.
+Якщо ми зберегли посилання на `elem.childNodes` і після цього додамо/видалимо вузли в DOM, вони автоматично з'являться в колекції.
 ```
 
 ````warn header="Не використовуйте `for..in` для перебору колекцій"
diff --git a/2-ui/1-document/04-searching-elements-dom/article.md b/2-ui/1-document/04-searching-elements-dom/article.md
index ae6a8c6f3..9b7aa13bc 100644
--- a/2-ui/1-document/04-searching-elements-dom/article.md
+++ b/2-ui/1-document/04-searching-elements-dom/article.md
@@ -37,12 +37,12 @@
   // elem -- це посилання на елемент DOM з id="elem"
   elem.style.background = 'red';
 
-  // id="elem-content" містить дефіс всередині, тому не може бути ім’ям змінної
+  // id="elem-content" містить дефіс всередині, тому не може бути ім'ям змінної
   // ...але ми можемо отримати доступ до нього за допомогою квадратних дужок: window['elem-content']
 </script>
 ```
 
-...Але це лише якщо ми не оголосили змінну JavaScript з таким же ім’ям, інакше вона матиме пріоритет:
+...Але це лише якщо ми не оголосили змінну JavaScript з таким же ім'ям, інакше вона матиме пріоритет:
 
 ```html run untrusted height=0
 <div id="elem"></div>
@@ -71,7 +71,7 @@
 ```
 
 ```warn header="Лише `document.getElementById`, а не `anyElem.getElementById`"
-Метод `getElementById` може бути викликаний лише на об’єкті `document`. Він шукає вказаний `id` у всьому документі.
+Метод `getElementById` може бути викликаний лише на об'єкті `document`. Він шукає вказаний `id` у всьому документі.
 ```
 
 ## querySelectorAll [#querySelectorAll]
@@ -251,7 +251,7 @@ document.getElementsByTagName('input')[0].value = 5;
 </form>
 
 <script>
-  // шукаємо за ім’ям атрибуту
+  // шукаємо за ім'ям атрибуту
   let form = document.getElementsByName('my-form')[0];
 
   // шукаємо за класом всередині form
@@ -344,7 +344,7 @@ document.getElementsByTagName('input')[0].value = 5;
 </tr>
 <tr>
 <td><code>getElementsByName</code></td>
-<td><code>ім’я</code></td>
+<td><code>ім'я</code></td>
 <td>-</td>
 <td>✔</td>
 </tr>
diff --git a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
index 4734fb006..d030e2fca 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
@@ -12,6 +12,6 @@
 
 Що відбувається крок за кроком:
 
-1. Вміст `<body>` замінюється коментарем. Коментар `<!--BODY-->`, тому що `body.tagName == "BODY"`. Як ми пам’ятаємо, `tagName` завжди пишеться великими літерами в HTML.
+1. Вміст `<body>` замінюється коментарем. Коментар `<!--BODY-->`, тому що `body.tagName == "BODY"`. Як ми пам'ятаємо, `tagName` завжди пишеться великими літерами в HTML.
 2. Коментар зараз є єдиним дочірнім вузлом, тому ми отримуємо його в `body.firstChild`.
 3. Властивість коментаря `data` -- це його вміст (всередині `<!--...-->`): `"BODY"`.
diff --git a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
index 353a37036..81e1c8bb4 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/solution.md
@@ -15,7 +15,7 @@ alert(document.constructor.name); // HTMLDocument
 
 Яке його місце в ієрархії?
 
-Так, ми могли б переглянути специфікацію, але було б швидше з’ясувати вручну.
+Так, ми могли б переглянути специфікацію, але було б швидше з'ясувати вручну.
 
 Давайте пройдемо по ланцюгу прототипів через `__proto__`.
 
@@ -37,4 +37,4 @@ alert(HTMLDocument.prototype.__proto__.__proto__.constructor.name); // Node
 
 Це ієрархія.
 
-Ми також можемо розглянути об’єкт за допомогою `console.dir(document)` і побачити ці назви, відкриваючи `__proto__`. Консоль браузера під капотом бере їх з `constructor`.
+Ми також можемо розглянути об'єкт за допомогою `console.dir(document)` і побачити ці назви, відкриваючи `__proto__`. Консоль браузера під капотом бере їх з `constructor`.
diff --git a/2-ui/1-document/05-basic-dom-node-properties/article.md b/2-ui/1-document/05-basic-dom-node-properties/article.md
index d75a9d28b..d953f9f7f 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/article.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/article.md
@@ -6,7 +6,7 @@
 
 ## Класи DOM вузлів
 
-Різні вузли DOM можуть мати різні властивості. Наприклад, елемент, що відповідає тегу `<a>`, має властивості, пов’язані з посиланням, тоді як елемент, що відповідає `<input>`, має властивості, пов’язані з введенням даних, тощо. Текстові вузли відрізняються від вузлів елементів. Проте, між ними також існують загальні властивості та методи, оскільки всі класи вузлів DOM утворюють єдину ієрархію.
+Різні вузли DOM можуть мати різні властивості. Наприклад, елемент, що відповідає тегу `<a>`, має властивості, пов'язані з посиланням, тоді як елемент, що відповідає `<input>`, має властивості, пов'язані з введенням даних, тощо. Текстові вузли відрізняються від вузлів елементів. Проте, між ними також існують загальні властивості та методи, оскільки всі класи вузлів DOM утворюють єдину ієрархію.
 
 Кожен вузол DOM належить відповідному вбудованому класу.
 
@@ -20,15 +20,15 @@
 
 - [EventTarget](https://dom.spec.whatwg.org/#eventtarget) -- це кореневий "абстрактний" клас клас для всього. 
 
-    Об’єкти цього класу ніколи не створюються. Він служить основою, тому всі вузли DOM підтримують так звані "події", які ми розглянемо пізніше.
+    Об'єкти цього класу ніколи не створюються. Він служить основою, тому всі вузли DOM підтримують так звані "події", які ми розглянемо пізніше.
 
 - [Node](https://dom.spec.whatwg.org/#interface-node) -- це також "абстрактний" клас, що служить базою для вузлів DOM. 
 
-    Він забезпечує основну функціональність дерева: `parentNode`, `nextSibling`, `childNodes` і так далі (це гетери). Об’єкти класу `Node` ніколи не створюються. Але є конкретні класи вузлів, які успадковуються від нього, і таким чином успадковують функціональність `Node`.
+    Він забезпечує основну функціональність дерева: `parentNode`, `nextSibling`, `childNodes` і так далі (це гетери). Об'єкти класу `Node` ніколи не створюються. Але є конкретні класи вузлів, які успадковуються від нього, і таким чином успадковують функціональність `Node`.
 
 - [Document](https://dom.spec.whatwg.org/#interface-document), з історичних причин часто успадковується `HTMLDocument` (хоча остання специфікація цього не диктує) -- це документ як ціле.
 
-    Глобальний об’єкт `document` належить саме цьому класу. Він служить точкою входу в DOM.
+    Глобальний об'єкт `document` належить саме цьому класу. Він служить точкою входу в DOM.
 
 - [CharacterData](https://dom.spec.whatwg.org/#interface-characterdata) -- "абстрактний" клас, успадкований:
     - [Text](https://dom.spec.whatwg.org/#interface-text) -- клас, що відповідає тексту всередині елементів, напр. `Hello` в `<p>Hello</p>`.
@@ -82,7 +82,7 @@
 
 Таким чином, повний набір властивостей та методів для певного вузла формується в результаті ланцюга успадкування.
 
-Наприклад, давайте розглянемо об’єкт DOM для елемента `<input>`. Він належить до класу [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement).
+Наприклад, давайте розглянемо об'єкт DOM для елемента `<input>`. Він належить до класу [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement).
 
 Він отримує властивості та методи шляхом "накладання" наступних класів (подані в порядку успадкування):
 
@@ -115,17 +115,17 @@ alert(document.body instanceof Node); // true
 alert(document.body instanceof EventTarget); // true
 ```
 
-Як ми бачимо, вузли DOM є звичайними об’єктами JavaScript. Вони використовують прототипні класи для успадкування.
+Як ми бачимо, вузли DOM є звичайними об'єктами JavaScript. Вони використовують прототипні класи для успадкування.
 
 Це також легко побачити, якщо вивести елемент за допомогою `console.dir(elem)` у браузері. Там в консолі ви побачите `HTMLElement.prototype`, `Element.prototype` і так далі.
 
 ```smart header="`console.dir(elem)` проти `console.log(elem)`"
-Більшість браузерів підтримують дві команди у своїх інструментах розробника: `console.log` та `console.dir`. Вони виводять свої аргументи в консоль. Для об’єктів JavaScript ці команди зазвичай працюють однаково.
+Більшість браузерів підтримують дві команди у своїх інструментах розробника: `console.log` та `console.dir`. Вони виводять свої аргументи в консоль. Для об'єктів JavaScript ці команди зазвичай працюють однаково.
 
 Але для DOM елементів вони різні:
 
 - `console.log(elem)` показує елемент в вигляді DOM дерева.
-- `console.dir(elem)` показує елемент як об’єкт DOM, це добре для того, щоб вивчити його властивості.
+- `console.dir(elem)` показує елемент як об'єкт DOM, це добре для того, щоб вивчити його властивості.
 
 Спробуйте це на `document.body`.
 ```
@@ -174,7 +174,7 @@ interface HTMLInputElement: HTMLElement {
 Вона має числове значення:
 - `elem.nodeType == 1` для вузлів-елементів,
 - `elem.nodeType == 3` для текстових вузлів,
-- `elem.nodeType == 9` для об’єкта документа,
+- `elem.nodeType == 9` для об'єкта документа,
 - [В специфікації](https://dom.spec.whatwg.org/#node) можна переглянути всі значення.
 
 Наприклад:
@@ -190,7 +190,7 @@ interface HTMLInputElement: HTMLElement {
   // і перший дочірній елемент ...
   alert(elem.firstChild.nodeType); // 3 => text
 
-  // для об’єкта document тип дорівнює 9
+  // для об'єкта document тип дорівнює 9
   alert( document.nodeType ); // 9
   </script>
 </body>
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/article.md b/2-ui/1-document/06-dom-attributes-and-properties/article.md
index 620e623b8..39e9dfbcd 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/article.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/article.md
@@ -1,8 +1,8 @@
 # Атрибути та властивості
 
-Коли браузер завантажує сторінку, він "читає" (іншими словами: "парсить") HTML і генерує DOM об’єкти з нього. Для вузлів-елементів більшість стандартних атрибутів HTML автоматично стають властивостями об'єктів DOM.
+Коли браузер завантажує сторінку, він "читає" (іншими словами: "парсить") HTML і генерує DOM об'єкти з нього. Для вузлів-елементів більшість стандартних атрибутів HTML автоматично стають властивостями об'єктів DOM.
 
-Наприклад, якщо тег це `<body id="page">`, тоді об’єкт DOM матиме `body.id="page"`.
+Наприклад, якщо тег це `<body id="page">`, тоді об'єкт DOM матиме `body.id="page"`.
 
 Але представлення атрибутів через властивості не відбувається один до одного! У цій главі ми звернемо увагу на відмінності цих двох концепцій, щоб навчитись, як з ними працювати, коли вони співпадають і коли відрізняються.
 
@@ -10,7 +10,7 @@
 
 Ми вже бачили вбудовані властивості DOM. Їх багато. Але технічно ніхто нас не обмежує, і якщо їх недостатньо, ми можемо додати власні.
 
-DOM вузли є звичайними об’єктами JavaScript. Ми можемо змінювати їх.
+DOM вузли є звичайними об'єктами JavaScript. Ми можемо змінювати їх.
 
 Наприклад, створімо нову властивість у `document.body`:
 
@@ -44,7 +44,7 @@ document.documentElement.sayHi(); // Привіт, Я HTML
 document.body.sayHi(); // Привіт, Я BODY
 ```
 
-Отже, властивості та методи DOM поводяться так само, як і звичайні об’єкти JavaScript:
+Отже, властивості та методи DOM поводяться так само, як і звичайні об'єкти JavaScript:
 
 - Вони можуть мати будь-яке значення.
 - Вони чутливі до регістру (наприклад `elem.nodeType`, не `elem.NoDeTyPe`).
@@ -201,7 +201,7 @@ document.body.sayHi(); // Привіт, Я BODY
 </script>
 ```
 
-Є й інші приклади. Атрибут `style` -- це рядок, але властивість `style` є об’єктом:
+Є й інші приклади. Атрибут `style` -- це рядок, але властивість `style` є об'єктом:
 
 ```html run
 <div id="div" style="color:red;font-size:120%">Привіт</div>
@@ -210,7 +210,7 @@ document.body.sayHi(); // Привіт, Я BODY
   // рядок
   alert(div.getAttribute('style')); // color:red;font-size:120%
 
-  // об’єкт
+  // об'єкт
   alert(div.style); // [object CSSStyleDeclaration]
   alert(div.style.color); // red
 </script>
@@ -307,7 +307,7 @@ document.body.sayHi(); // Привіт, Я BODY
 div.setAttribute('order-state', 'canceled');
 ```
 
-Але може виникнути потенційна проблема з користувацькими атрибутами. Що робити, якщо ми використовуємо нестандартний атрибут для наших цілей, а потім стандарт вводить його та надає йому якусь функціональність? Мова HTML жива, вона зростає, а також з’являється більше атрибутів, які відповідають потребам розробників. У такому випадку можуть виникнути неочікувані наслідки.
+Але може виникнути потенційна проблема з користувацькими атрибутами. Що робити, якщо ми використовуємо нестандартний атрибут для наших цілей, а потім стандарт вводить його та надає йому якусь функціональність? Мова HTML жива, вона зростає, а також з'являється більше атрибутів, які відповідають потребам розробників. У такому випадку можуть виникнути неочікувані наслідки.
 
 Щоб уникнути конфліктів, існують [data-*](https://html.spec.whatwg.org/#embedding-custom-non-visible-data-with-the-data-*-attributes) атрибути.
 
@@ -363,7 +363,7 @@ div.setAttribute('order-state', 'canceled');
 ## Підсумки
 
 - Атрибути -- це те, що написано в HTML.
-- Властивості -- це те, що є в об’єктах DOM.
+- Властивості -- це те, що є в об'єктах DOM.
 
 Невелике порівняння:
 
diff --git a/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.md b/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.md
index 431c9f736..f52f4fdcc 100644
--- a/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.md
+++ b/2-ui/1-document/07-modifying-document/10-clock-setinterval/solution.md
@@ -54,4 +54,4 @@ function clockStop() {
 
 Будь ласка, зверніть увагу, що виклик `update()` не тільки заплановано в `clockStart()`, а ще й негайно виконується в рядку `(*)`. Інакше відвідувач повинен був би чекати до першого виконання `setInterval`. І до того часу годинник був би порожнім.
 
-Також важливо встановити новий інтервал у `clockStart()` лише тоді, коли годинник не працює. Інакше натискання кнопки «Пуск» кілька разів встановить кілька одночасних інтервалів. Ще гірше -- ми запам’ятаємо лише `timerID` останнього інтервалу, втративши посилання на всі інші. В такому разі ми б ніколи більше не змогли зупинити годинник! Зауважте, в рядку `(**)` нам потрібно очистити `timerID`, коли годинник зупинено, щоб його можна було знову увімкнути, запустивши `clockStart()`.
+Також важливо встановити новий інтервал у `clockStart()` лише тоді, коли годинник не працює. Інакше натискання кнопки «Пуск» кілька разів встановить кілька одночасних інтервалів. Ще гірше -- ми запам'ятаємо лише `timerID` останнього інтервалу, втративши посилання на всі інші. В такому разі ми б ніколи більше не змогли зупинити годинник! Зауважте, в рядку `(**)` нам потрібно очистити `timerID`, коли годинник зупинено, щоб його можна було знову увімкнути, запустивши `clockStart()`.
diff --git a/2-ui/1-document/07-modifying-document/12-sort-table/solution.md b/2-ui/1-document/07-modifying-document/12-sort-table/solution.md
index 11d411f00..ee963f1a0 100644
--- a/2-ui/1-document/07-modifying-document/12-sort-table/solution.md
+++ b/2-ui/1-document/07-modifying-document/12-sort-table/solution.md
@@ -10,7 +10,7 @@ table.tBodies[0].append(...sortedRows); // (3)
 Покроковий алгоритм:
 
 1. Отримати всі `<tr>` з `<tbody>`.
-2. Потім відсортувати їх порівнюючи за вмістом першого `<td>` (поле «Ім’я»).
+2. Потім відсортувати їх порівнюючи за вмістом першого `<td>` (поле «Ім'я»).
 3. Вставити вузли в правильному порядку `.append(...sortedRows)`.
 
 Нам не потрібно видаляти існуючі рядки з таблиці, лише повторно вставити і вони автоматично залишать своє попереднє місце розташування.
diff --git a/2-ui/1-document/07-modifying-document/12-sort-table/task.md b/2-ui/1-document/07-modifying-document/12-sort-table/task.md
index 1ddfa7c50..0dc60fd3d 100644
--- a/2-ui/1-document/07-modifying-document/12-sort-table/task.md
+++ b/2-ui/1-document/07-modifying-document/12-sort-table/task.md
@@ -10,7 +10,7 @@ importance: 5
 <table>
 <thead>
   <tr>
-    <th>Ім’я</th><th>Прізвище</th><th>Вік</th>
+    <th>Ім'я</th><th>Прізвище</th><th>Вік</th>
   </tr>
 </thead>
 <tbody>
diff --git a/2-ui/1-document/07-modifying-document/7-create-object-tree/solution.md b/2-ui/1-document/07-modifying-document/7-create-object-tree/solution.md
index 317a414ed..0091ecb7c 100644
--- a/2-ui/1-document/07-modifying-document/7-create-object-tree/solution.md
+++ b/2-ui/1-document/07-modifying-document/7-create-object-tree/solution.md
@@ -1,4 +1,4 @@
-Найпростіший спосіб обійти об’єкт -- скористатися рекурсією.
+Найпростіший спосіб обійти об'єкт -- скористатися рекурсією.
 
 1. [Рішення з innerHTML](sandbox:innerhtml).
 2. [Рішення з DOM](sandbox:build-tree-dom).
diff --git a/2-ui/1-document/07-modifying-document/7-create-object-tree/task.md b/2-ui/1-document/07-modifying-document/7-create-object-tree/task.md
index 79aa5a984..aa961bb76 100644
--- a/2-ui/1-document/07-modifying-document/7-create-object-tree/task.md
+++ b/2-ui/1-document/07-modifying-document/7-create-object-tree/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Створіть дерево з об’єкту
+# Створіть дерево з об'єкту
 
-Напишіть функцію `createTree` яка створює вкладений `ul/li` список з вкладеного об’єкта.
+Напишіть функцію `createTree` яка створює вкладений `ul/li` список з вкладеного об'єкта.
 
 Наприклад:
 
diff --git a/2-ui/1-document/07-modifying-document/9-calendar-table/solution.md b/2-ui/1-document/07-modifying-document/9-calendar-table/solution.md
index 42484b8c6..de2ef8860 100644
--- a/2-ui/1-document/07-modifying-document/9-calendar-table/solution.md
+++ b/2-ui/1-document/07-modifying-document/9-calendar-table/solution.md
@@ -3,7 +3,7 @@
 Алгоритм:
 
 1. Створіть заголовок таблиці з `<th>` та днями тижня.
-2. Створіть об’єкт дати `d = new Date(year, month-1)`. Це перший день місяця `month` (беручи до уваги, що місяці в JavaScript починаються з `0`, а не з `1`).
+2. Створіть об'єкт дати `d = new Date(year, month-1)`. Це перший день місяця `month` (беручи до уваги, що місяці в JavaScript починаються з `0`, а не з `1`).
 3. Декілька перших клітинок до `d.getDay()` можуть бути пустими. Заповнимо їх `<td></td>`.
 4. Збільшуйте день `d`: `d.setDate(d.getDate()+1)`. Якщо `d.getMonth()` ще не досяг наступного місяця, тоді додайте нову клітинку `<td>` в календар. Якщо це НД, тоді додайте новий рядок <code>"&lt;/tr&gt;&lt;tr&gt;"</code>.
 5. Якщо міcяць завершився, але рядок таблиці ще не заповнений, додайте пусті `<td>`, щоб надати таблиці правильної форми.
diff --git a/2-ui/1-document/07-modifying-document/article.md b/2-ui/1-document/07-modifying-document/article.md
index 4f1bbdbdc..693dbdb01 100644
--- a/2-ui/1-document/07-modifying-document/article.md
+++ b/2-ui/1-document/07-modifying-document/article.md
@@ -69,7 +69,7 @@ div.innerHTML = "<strong>Всім привіт!</strong> Ви прочитали
 
 ## Методи вставки
 
-Щоб `div` з’явився нам потрібно вставити його десь в `document`. Наприклад, в елемент `<body>` який можна отримати звернувшись до `document.body`.
+Щоб `div` з'явився нам потрібно вставити його десь в `document`. Наприклад, в елемент `<body>` який можна отримати звернувшись до `document.body`.
 
 Для цього існує спеціальний метод `append`: `document.body.append(div)`.
 
@@ -163,7 +163,7 @@ after
 </script>
 ```
 
-Пам’ятайте, що текст вставляється «як текст», а не «як HTML», з відповідними замінами таких символів як `<`, `>`.
+Пам'ятайте, що текст вставляється «як текст», а не «як HTML», з відповідними замінами таких символів як `<`, `>`.
 
 Тому фінальний HTML буде таким:
 
diff --git a/2-ui/1-document/08-styles-and-classes/article.md b/2-ui/1-document/08-styles-and-classes/article.md
index 57f354a90..67ac967eb 100644
--- a/2-ui/1-document/08-styles-and-classes/article.md
+++ b/2-ui/1-document/08-styles-and-classes/article.md
@@ -27,7 +27,7 @@ elem.style.top = top; // наприклад '456px'
 
 Зміна класу є однією з найчастіше використовуваних дій у скриптах.
 
-В давні часи JavaScript мав певні обмеження: зарезервоване слово, таке як `"class"`, не могло бути властивістю об’єкта. Цього обмеження наразі більше немає, проте на той час було неможливо мати властивість `"class"`, як от `elem.class`.
+В давні часи JavaScript мав певні обмеження: зарезервоване слово, таке як `"class"`, не могло бути властивістю об'єкта. Цього обмеження наразі більше немає, проте на той час було неможливо мати властивість `"class"`, як от `elem.class`.
 
 Тому для класів було додано схожу на вигляд властивість `"className"`: `elem.className` відповідає атрибуту `"class"`.
 
@@ -45,7 +45,7 @@ elem.style.top = top; // наприклад '456px'
 
 Для цього існує інша властивість, а саме `elem.classList`.
 
-Властивість `elem.classList` -- це спеціальний об’єкт, який містить методи для додавання, видалення або перемикання окремого класу.
+Властивість `elem.classList` -- це спеціальний об'єкт, який містить методи для додавання, видалення або перемикання окремого класу.
 
 Наприклад:
 
@@ -70,7 +70,7 @@ elem.style.top = top; // наприклад '456px'
 - `elem.classList.toggle("class")` -- додає клас, якщо він не існує, інакше видаляє його.
 - `elem.classList.contains("class")` -- перевіряє, чи існує переданий клас, відповідно повертає `true/false`.
 
-Крім того, `classList` -- це ітерований об’єкт, тому можна легко вивести перелік всіх класів циклом `for..of`, як показано далі:
+Крім того, `classList` -- це ітерований об'єкт, тому можна легко вивести перелік всіх класів циклом `for..of`, як показано далі:
 
 ```html run
 <body class="main page">
@@ -84,7 +84,7 @@ elem.style.top = top; // наприклад '456px'
 
 ## Стилі елемента
 
-Властивість `elem.style` -- це об’єкт, вміст якого відповідає тому, що записано в атрибуті `"style"`. Встановлення `elem.style.width="100px"` працює точнісінько так само, як рядок `width:100px` записаний в атрибут `style`.
+Властивість `elem.style` -- це об'єкт, вміст якого відповідає тому, що записано в атрибуті `"style"`. Встановлення `elem.style.width="100px"` працює точнісінько так само, як рядок `width:100px` записаний в атрибут `style`.
 
 Для властивостей, які називаються кількома словами, використовується верблюдячий регістр (camelCase):
 
@@ -137,7 +137,7 @@ setTimeout(() => document.body.style.removeProperty('background'), 1000); // в
 ```
 
 ````smart header="Повний перезапис за допомогою `style.cssText`"
-Зазвичай, `style.*` використовується для встановлення окремих властивостей стилю. Немає можливості задати весь стиль, як от `div.style="color: red; width: 100px"`, оскільки `div.style` -- це об’єкт, і він доступний лише для читання.
+Зазвичай, `style.*` використовується для встановлення окремих властивостей стилю. Немає можливості задати весь стиль, як от `div.style="color: red; width: 100px"`, оскільки `div.style` -- це об'єкт, і він доступний лише для читання.
 
 Існує спеціальна властивість `style.cssText`, яка дає змогу встановлювати повний стиль елемента як рядок:
 
@@ -161,7 +161,7 @@ setTimeout(() => document.body.style.removeProperty('background'), 1000); // в
 Того самого можна досягнути шляхом встановлення значення атрибута: `div.setAttribute('style', 'color: red...')`.
 ````
 
-## Пам’ятайте про одиниці вимірювання
+## Пам'ятайте про одиниці вимірювання
 
 Не забувайте додавати одиниці вимірювання CSS до значень.
 
@@ -232,7 +232,7 @@ element
 pseudo
 : Вказується, якщо потрібен стиль псевдоелемента, наприклад: `::before`. Порожній рядок, або опущений аргумент означатимуть, що буде опрацьовано сам елемент.
 
-В результаті виклику методу буде повернено об’єкт зі стилями, подібно до `elem.style`, але зі врахуванням всіх класів CSS.
+В результаті виклику методу буде повернено об'єкт зі стилями, подібно до `elem.style`, але зі врахуванням всіх класів CSS.
 
 Наприклад:
 
@@ -284,14 +284,14 @@ JavaScript не бачить стилі, застосовані через се
 Існує дві властивості DOM для керування класами:
 
 - `className` -- рядкове значення, гарно підходить для керування всім набором класів елемента в цілому.
-- `classList` -- об’єкт з методами `add/remove/toggle/contains`, підходить для роботи з окремими класами.
+- `classList` -- об'єкт з методами `add/remove/toggle/contains`, підходить для роботи з окремими класами.
 
 Для зміни стилів:
 
-- Властивість `style` -- об’єкт зі стилями, записаними верблюдячим регістром (camelCase). Читання і запис у неї має такий самий зміст, як і модифікація окремих властивостей в атрибуті `"style"`. Щоб побачити, як застосовується `important` та інші рідкісні речі -- на [MDN](mdn:api/CSSStyleDeclaration) описано перелік методів.
+- Властивість `style` -- об'єкт зі стилями, записаними верблюдячим регістром (camelCase). Читання і запис у неї має такий самий зміст, як і модифікація окремих властивостей в атрибуті `"style"`. Щоб побачити, як застосовується `important` та інші рідкісні речі -- на [MDN](mdn:api/CSSStyleDeclaration) описано перелік методів.
 
 - Властивість `style.cssText` показує атрибут `"style"` в цілому, весь рядок стилів.
 
 Для зчитування кінцевих стилів (з врахуванням всіх класів, після застосування всього CSS і обчислення остаточних значень):
 
-- Метод `getComputedStyle(elem, [pseudo])` повертає об’єкт, подібний до властивості `style`, з кінцевими значеннями. Виключно для читання.
+- Метод `getComputedStyle(elem, [pseudo])` повертає об'єкт, подібний до властивості `style`, з кінцевими значеннями. Виключно для читання.
diff --git a/2-ui/1-document/09-size-and-scroll/article.md b/2-ui/1-document/09-size-and-scroll/article.md
index 16c7269ea..475bdf19b 100644
--- a/2-ui/1-document/09-size-and-scroll/article.md
+++ b/2-ui/1-document/09-size-and-scroll/article.md
@@ -256,7 +256,7 @@ alert( getComputedStyle(elem).width ); // показує CSS-ширину elem
 
 Елемент із текстом має CSS `width:300px`.
 
-На комп’ютері в ОС Windows, Firefox, Chrome, Edge резервується місце для смуги прокрутки. Але Firefox показує `300px`, а Chrome і Edge -- менше. Це тому, що Firefox повертає ширину CSS, а інші браузери повертають "реальну" ширину.
+На комп'ютері в ОС Windows, Firefox, Chrome, Edge резервується місце для смуги прокрутки. Але Firefox показує `300px`, а Chrome і Edge -- менше. Це тому, що Firefox повертає ширину CSS, а інші браузери повертають "реальну" ширину.
 ```
 
 Зверніть увагу, що описана різниця стосується лише читання `getComputedStyle(...).width` з JavaScript, візуально все правильно.
diff --git a/2-ui/1-document/10-size-and-scroll-window/article.md b/2-ui/1-document/10-size-and-scroll-window/article.md
index 86f355c02..0e627e7ba 100644
--- a/2-ui/1-document/10-size-and-scroll-window/article.md
+++ b/2-ui/1-document/10-size-and-scroll-window/article.md
@@ -62,7 +62,7 @@ alert('Повна висота документа з прокрученою ча
 
 Стан прокрутки документа міститься в `document.documentElement.scrollLeft/scrollTop`, та працює в більшості браузерів, за винятком старіших браузерів створених на WebKit, таких як Safari (помилка [5991](https://bugs.webkit.org/show_bug.cgi?id=5991)), де ми повинні використовувати `document.body` замість `document.documentElement`.
 
-На щастя, нам не потрібно пам’ятати про ці особливості, оскільки прокрутка доступна у спеціальних властивостях `window.pageXOffset/pageYOffset`:
+На щастя, нам не потрібно пам'ятати про ці особливості, оскільки прокрутка доступна у спеціальних властивостях `window.pageXOffset/pageYOffset`:
 
 ```js run
 alert('Поточна прокрутка зверху: ' + window.pageYOffset);
@@ -112,8 +112,8 @@ alert('Поточна прокрутка зліва: ' + window.pageXOffset);
 
 Виклик `elem.scrollIntoView(top)` прокручує сторінку таким чином, щоб зробити `elem` видимим. Він має один аргумент:
 
-- Якщо `top=true` (типове значення), то сторінка буде прокручена так, щоб `elem` з’явився у верхній частині вікна. Верхній край елемента буде вирівняний з верхньою частиною вікна.
-- Якщо `top=false`, то сторінка прокручується так, щоб `elem` з’явився внизу. Нижній край елемента буде вирівняний з нижньою частиною вікна.
+- Якщо `top=true` (типове значення), то сторінка буде прокручена так, щоб `elem` з'явився у верхній частині вікна. Верхній край елемента буде вирівняний з верхньою частиною вікна.
+- Якщо `top=false`, то сторінка прокручується так, щоб `elem` з'явився внизу. Нижній край елемента буде вирівняний з нижньою частиною вікна.
 
 ```online
 Кнопка нижче прокручує сторінку, щоб розмістити себе у верхній частині вікна:
diff --git a/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md b/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
index 049eac3d1..4b3ef7fc5 100644
--- a/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
+++ b/2-ui/1-document/11-coordinates/1-find-point-coordinates/task.md
@@ -21,4 +21,4 @@
 
 Обчислені координати повинні збігатися з тими, які повертаються клацанням миші.
 
-P.S. Код також повинен працювати, якщо елемент має інший розмір або рамку, тобто не прив’язаний до жодних фіксованих значень.
+P.S. Код також повинен працювати, якщо елемент має інший розмір або рамку, тобто не прив'язаний до жодних фіксованих значень.
diff --git a/2-ui/1-document/11-coordinates/3-position-at-absolute/task.md b/2-ui/1-document/11-coordinates/3-position-at-absolute/task.md
index c48348079..84ff31301 100644
--- a/2-ui/1-document/11-coordinates/3-position-at-absolute/task.md
+++ b/2-ui/1-document/11-coordinates/3-position-at-absolute/task.md
@@ -8,4 +8,4 @@
 
 Це запобіжить «втечу» нотатки від елемента під час прокручування сторінки.
 
-Візьміть розв’язання попереднього завдання за відправну точку. Щоб перевірити прокрутку, додайте стиль `<body style="height: 2000px">`.
+Візьміть розв'язання попереднього завдання за відправну точку. Щоб перевірити прокрутку, додайте стиль `<body style="height: 2000px">`.
diff --git a/2-ui/1-document/11-coordinates/4-position-inside-absolute/task.md b/2-ui/1-document/11-coordinates/4-position-inside-absolute/task.md
index ce5a61c2f..49e8320a8 100644
--- a/2-ui/1-document/11-coordinates/4-position-inside-absolute/task.md
+++ b/2-ui/1-document/11-coordinates/4-position-inside-absolute/task.md
@@ -25,4 +25,4 @@ positionAt(blockquote, "top-in", note);
 
 [iframe src="solution" height="310" border="1" link]
 
-Для початку візьміть розв’язання задачі <info:task/position-at-absolute>.
+Для початку візьміть розв'язання задачі <info:task/position-at-absolute>.
diff --git a/2-ui/1-document/11-coordinates/article.md b/2-ui/1-document/11-coordinates/article.md
index fca00d4dd..8262b6255 100644
--- a/2-ui/1-document/11-coordinates/article.md
+++ b/2-ui/1-document/11-coordinates/article.md
@@ -21,14 +21,14 @@
 
 ## Координати елемента відносно вікна: getBoundingClientRect
 
-Метод `elem.getBoundingClientRect()` повертає координати у контексті вікна для мінімального за розмірами прямокутника, який вміщує `elem` у вигляді об’єкта вбудованого класу [DOMRect](https://www.w3.org/TR/geometry-1/#domrect).
+Метод `elem.getBoundingClientRect()` повертає координати у контексті вікна для мінімального за розмірами прямокутника, який вміщує `elem` у вигляді об'єкта вбудованого класу [DOMRect](https://www.w3.org/TR/geometry-1/#domrect).
 
 Основні властивості `DOMRect`:
 
 - `x/y` -- координати X/Y початку прямокутника відносно вікна,
-- `width/height` -- ширина/висота прямокутника (можуть бути від’ємними).
+- `width/height` -- ширина/висота прямокутника (можуть бути від'ємними).
 
-Крім того, в об’єкті містяться такі похідні властивості:
+Крім того, в об'єкті містяться такі похідні властивості:
 
 - `top/bottom` -- Y-координата для верхнього/нижнього краю прямокутника,
 - `left/right` -- X-координата для лівого/правого краю прямокутника.
@@ -70,16 +70,16 @@ right:${r.right}
 Зверніть увагу:
 
 - Координати можуть бути десятковими дробами, наприклад `10.5`. Це нормально, тому, що внутрішньо браузер використовує дроби у своїх обчисленнях. Нам не потрібно їх округлювати, коли встановлюємо значення `style.left/top`.
-– Координати можуть бути від’ємними. Наприклад, якщо сторінка прокручена таким чином, що `elem` знаходиться над видимою частиною вікна, то `elem.getBoundingClientRect().top` буде від’ємними.
+– Координати можуть бути від'ємними. Наприклад, якщо сторінка прокручена таким чином, що `elem` знаходиться над видимою частиною вікна, то `elem.getBoundingClientRect().top` буде від'ємними.
 
 ```smart header="Навіщо потрібні похідні властивості? Чому існує `top/left`, якщо є `x/y`?"
 Математично прямокутник однозначно визначається його початковою точкою `(x,y)` і вектором напрямку `(width,height)`. Тому додаткові похідні властивості призначені для зручності.
 
-Технічно можливо, щоб `width/height` були від’ємними, це дозволяє використовувати «спрямований» прямокутник, наприклад для представлення виділення мишею з правильно позначеними початком і кінцем.
+Технічно можливо, щоб `width/height` були від'ємними, це дозволяє використовувати «спрямований» прямокутник, наприклад для представлення виділення мишею з правильно позначеними початком і кінцем.
 
-Від’ємні значення `width/height` означають, що прямокутник починається з нижнього правого кута, а потім "зростає" ліворуч вгору.
+Від'ємні значення `width/height` означають, що прямокутник починається з нижнього правого кута, а потім "зростає" ліворуч вгору.
 
-Ось прямокутник із від’ємними значеннями `width` і `height` (наприклад, `width=-200`, `height=-100`):
+Ось прямокутник із від'ємними значеннями `width` і `height` (наприклад, `width=-200`, `height=-100`):
 
 ![](coordinates-negative.svg)
 
@@ -129,7 +129,7 @@ alert(elem.tagName);
 ````warn header="Для координат, які знаходяться поза вікном `elementFromPoint` повертає `null`"
 Метод `document.elementFromPoint(x,y)` працює, лише якщо координати `(x,y)` знаходяться у видимій області вікна.
 
-Якщо будь-яка з координат від’ємна, або більша ніж ширина/висота вікна, то повертається `null`.
+Якщо будь-яка з координат від'ємна, або більша ніж ширина/висота вікна, то повертається `null`.
 
 Ось типова помилка, яка може виникнути, якщо не додати перевірку:
 
@@ -182,7 +182,7 @@ setTimeout(() => message.remove(), 5000);
 ```online
 Натисніть кнопку, щоб запустити приклад:
 
-<button id="coords-show-mark">Кнопка з id="coords-show-mark", під нею з’явиться повідомлення</button>
+<button id="coords-show-mark">Кнопка з id="coords-show-mark", під нею з'явиться повідомлення</button>
 ```
 
 Код можна змінити, щоб показати повідомлення ліворуч, праворуч, знизу, застосувати CSS анімацію, і так далі. Це легко, оскільки у нас є всі координати та розміри елемента.
@@ -203,7 +203,7 @@ setTimeout(() => message.remove(), 5000);
 
 Не існує стандартного методу для отримання координат елемента відносно до документа. Але написати його легко.
 
-Дві системи координат з’єднуються за формулою:
+Дві системи координат з'єднуються за формулою:
 - `pageY` = `clientY` + висота прокрученої вертикальної частини документа.
 - `pageX` = `clientX` + ширина прокрученої горизонтальної частини документа.
 
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
index 92e54355c..f34312ce8 100644
--- a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
+++ b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/solution.md
@@ -1,11 +1,11 @@
 
-Спочатку ми маємо вибрати метод позиціювання м’яча.
+Спочатку ми маємо вибрати метод позиціювання м'яча.
 
-Ми не можемо використати `position:fixed` для цього, оскільки прокручування сторінки переміщатиме м’яч поля.
+Ми не можемо використати `position:fixed` для цього, оскільки прокручування сторінки переміщатиме м'яч поля.
 
 Правильніше використовувати `position:absolute` і, щоб зробити позиціювання справді надійним, зробимо саме поле `field` позиціонованим.
 
-Тоді м’яч буде позиціонований щодо поля:
+Тоді м'яч буде позиціонований щодо поля:
 
 ```css
 #field {
@@ -18,7 +18,7 @@
   position: absolute;
   left: 0; /* по відношенню до найближчого розташованого предка (field) */
   top: 0;
-  transition: 1s all; /* CSS-анімація для значень left/top робить пересування м’яча плавним */
+  transition: 1s all; /* CSS-анімація для значень left/top робить пересування м'яча плавним */
 }
 ```
 
@@ -30,15 +30,15 @@
 
 Ми маємо `event.clientX/clientY` -- координати натискання мишки щодо вікна браузера.
 
-Щоб отримати значення `left` для м’яча після натискання мишки щодо поля, ми повинні від координати натискання мишки відняти координату лівого краю поля та ширину межі:
+Щоб отримати значення `left` для м'яча після натискання мишки щодо поля, ми повинні від координати натискання мишки відняти координату лівого краю поля та ширину межі:
 
 ```js
 let left = event.clientX - fieldCoords.left - field.clientLeft;
 ```
 
-Значення `ball.style.left` означає «лівий край елемента» (м’яча). І якщо ми призначимо такий `left` для м’яча, то його ліва межа, а не центр, буде під курсором миші.
+Значення `ball.style.left` означає «лівий край елемента» (м'яча). І якщо ми призначимо такий `left` для м'яча, то його ліва межа, а не центр, буде під курсором миші.
 
-Нам потрібно зрушити м'яч на половину його висоти вгору та половину його ширини вліво, щоб центр м’яча точно збігався з точкою натискання мишки.
+Нам потрібно зрушити м'яч на половину його висоти вгору та половину його ширини вліво, щоб центр м'яча точно збігався з точкою натискання мишки.
 
 У результаті значення для `left` буде таким:
 
@@ -48,4 +48,4 @@ let left = event.clientX - fieldCoords.left - field.clientLeft - ball.offsetWidt
 
 Вертикальна координата обчислюватиметься за тією ж логікою.
 
-Слід пам’ятати, що ширина та висота м’яча має бути відома в той момент, коли ми отримуємо значення `ball.offsetWidth`. Це значення може бути задано в HTML або CSS.
+Слід пам'ятати, що ширина та висота м'яча має бути відома в той момент, коли ми отримуємо значення `ball.offsetWidth`. Це значення може бути задано в HTML або CSS.
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/task.md b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/task.md
index ab0fca0aa..d8c92a8c0 100644
--- a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/task.md
+++ b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/task.md
@@ -2,20 +2,20 @@ importance: 5
 
 ---
 
-# Пересуньте м’яч по полю
+# Пересуньте м'яч по полю
 
-Нехай м’яч переміщається при натисканні на поле, туди, де був клік, ось так:
+Нехай м'яч переміщається при натисканні на поле, туди, де був клік, ось так:
 
 [iframe src="solution" height="260" link]
 
 Вимоги:
 
-- Центр м’яча повинен збігатися з курсором миші (якщо це можливо без перетину країв поля);
-- CSS-анімація бажана, але не є обов’язковою;
-- М’яч у жодному разі не повинен перетинати межі поля;
+- Центр м'яча повинен збігатися з курсором миші (якщо це можливо без перетину країв поля);
+- CSS-анімація бажана, але не є обов'язковою;
+- М'яч у жодному разі не повинен перетинати межі поля;
 - При прокручуванні сторінки нічого не повинно ламатися;
 
 Нотатки:
 
-- Код повинен уміти працювати з різними розмірами м’яча та поля, не прив’язуватися до будь-яких фіксованих значень.
+- Код повинен уміти працювати з різними розмірами м'яча та поля, не прив'язуватися до будь-яких фіксованих значень.
 - Використовуйте властивості `event.clientX/event.clientY`, щоб вирахувати координати миші при кліці.
diff --git a/2-ui/2-events/01-introduction-browser-events/article.md b/2-ui/2-events/01-introduction-browser-events/article.md
index 5b5d7dfa1..600422567 100644
--- a/2-ui/2-events/01-introduction-browser-events/article.md
+++ b/2-ui/2-events/01-introduction-browser-events/article.md
@@ -64,9 +64,9 @@
 <input type="button" *!*onclick="countRabbits()"*/!* value="Рахувати кроликів!">
 ```
 
-Як ми пам’ятаємо, атрибут HTML-тега не чутливий до регістру, тому `ONCLICK` буде працювати так само як `onClick` і `onCLICK`… Але, як правило, атрибути пишуть у нижньому регістрі `onclick`.
+Як ми пам'ятаємо, атрибут HTML-тега не чутливий до регістру, тому `ONCLICK` буде працювати так само як `onClick` і `onCLICK`… Але, як правило, атрибути пишуть у нижньому регістрі `onclick`.
 
-### Використання властивостей DOM-об’єкта
+### Використання властивостей DOM-об'єкта
 
 Можемо призначати обробник, використовуючи властивість DOM-елемента `on<event>`.
 
@@ -109,7 +109,7 @@
 
 У першому прикладі використовувався атрибут HTML для ініціалізації `button.onclick`, тоді як у другому прикладі -- сценарій, ось і вся різниця.
 
-**Оскільки в елемента DOM може бути тільки одна властивість з ім’ям `onclick`, то призначити більше одного обробника таким чином не можна.**
+**Оскільки в елемента DOM може бути тільки одна властивість з ім'ям `onclick`, то призначити більше одного обробника таким чином не можна.**
 
 У прикладі нижче призначення обробника додатково через JavaScript перезапише обробник з атрибуту:
 
@@ -222,7 +222,7 @@ element.addEventListener(event, handler, [options]);
 : Посилання на функцію-обробник.
 
 `options`
-: Додатковий об’єкт із властивостями:
+: Додатковий об'єкт із властивостями:
     - `once`: якщо `true`, тоді обробник буде автоматично вилучений після виконання.
     - `capture`: фаза, на якій повинен спрацювати обробник, докладніше про це буде розказано у розділі <info:bubbling-and-capturing>. Так історично склалося, що `options` може бути `false/true`, це те саме, що `{capture: false/true}`.
     - `passive`: якщо `true`, тоді обробник ніколи не викличе `preventDefault()`, докладніше про це буде розказано у розділі <info:default-browser-action>.
@@ -306,7 +306,7 @@ document.addEventListener("DOMContentLoaded", function() {
 Таким чином `addEventListener` більш універсальний. Хоча зауважимо, що таких подій меншість, це скоріше виняток, ніж правило.
 ````
 
-## Об’єкт події
+## Об'єкт події
 
 Щоб правильно обробити подію, можуть знадобитися деталі того, що сталося. Не просто "клік" або "натискання клавіші", але й координати вказівника миші, яка саме клавіша натиснута і так далі.
 
@@ -326,21 +326,21 @@ document.addEventListener("DOMContentLoaded", function() {
 </script>
 ```
 
-Деякі властивості об’єкту `event`:
+Деякі властивості об'єкту `event`:
 
 `event.type`
 : Тип події, у цьому випадку `"click"`.
 
 `event.currentTarget`
-: Елемент, у якому спрацював обробник. Це значення зазвичай таке саме, як і в `this`, але якщо обробник є функцією-стрілкою чи за допомогою `bind` прив’язаний інший об’єкт `this`, то ми можемо отримати елемент з `event.currentTarget`.
+: Елемент, у якому спрацював обробник. Це значення зазвичай таке саме, як і в `this`, але якщо обробник є функцією-стрілкою чи за допомогою `bind` прив'язаний інший об'єкт `this`, то ми можемо отримати елемент з `event.currentTarget`.
 
 `event.clientX / event.clientY`
 : Координати курсору в момент кліку у площині вікна для подій миші.
 
 Існує багато властивостей подій. Більшість з них залежать від типу події: події клавіатури мають один набір подій, а події вказівника -- інший. Ми розглянемо детальніше деякі з них пізніше.
 
-````smart header="Об’єкт події доступний і в HTML"
-При призначенні обробника в HTML теж можна використовувати об’єкт `event`, ось так:
+````smart header="Об'єкт події доступний і в HTML"
+При призначенні обробника в HTML теж можна використовувати об'єкт `event`, ось так:
 
 ```html autorun height=60
 <input type="button" onclick="*!*alert(event.type)*/!*" value="Тип події">
@@ -350,9 +350,9 @@ document.addEventListener("DOMContentLoaded", function() {
 ````
 
 
-## Об’єкт-обробник: handleEvent
+## Об'єкт-обробник: handleEvent
 
-Ми можемо призначити обробником не лише функцію, а й об’єкт за допомогою `addEventListener`. У такому разі, коли відбувається подія, викликається метод об’єкта `handleEvent`.
+Ми можемо призначити обробником не лише функцію, а й об'єкт за допомогою `addEventListener`. У такому разі, коли відбувається подія, викликається метод об'єкта `handleEvent`.
 
 Наприклад:
 
@@ -371,7 +371,7 @@ document.addEventListener("DOMContentLoaded", function() {
 </script>
 ```
 
-Як бачимо, якщо `addEventListener` отримує об’єкт як обробник, він викликає `obj.handleEvent(event)`, коли відбувається подія.
+Як бачимо, якщо `addEventListener` отримує об'єкт як обробник, він викликає `obj.handleEvent(event)`, коли відбувається подія.
 
 Ми також можемо використати клас для цього, ось так:
 
@@ -402,9 +402,9 @@ document.addEventListener("DOMContentLoaded", function() {
 </script>
 ```
 
-Тут той самий об’єкт обробляє обидві події. Зверніть увагу, ми повинні явно призначити обидва обробники через `addEventListener`. Тоді об’єкт `menu` отримуватиме події `mousedown` та `mouseup`, а не інші (не призначені) типи подій.
+Тут той самий об'єкт обробляє обидві події. Зверніть увагу, ми повинні явно призначити обидва обробники через `addEventListener`. Тоді об'єкт `menu` отримуватиме події `mousedown` та `mouseup`, а не інші (не призначені) типи подій.
 
-Метод `handleEvent` не обов’язково має виконувати всю роботу сам. Він може викликати інші методи, які створені під обробку конкретних типів подій, ось так:
+Метод `handleEvent` не обов'язково має виконувати всю роботу сам. Він може викликати інші методи, які створені під обробку конкретних типів подій, ось так:
 
 ```html run
 <button id="elem">Натисни мене</button>
@@ -446,8 +446,8 @@ HTML-атрибути використовуються рідко тому, що
 
 DOM-властивості можна використовувати, але ми не можемо призначити більше одного обробника на один тип події. У багатьох випадках із цим обмеженням можна миритися.
 
-Останній спосіб найбільш гнучкий, проте потрібно писати більше коду. Є кілька типів подій, які працюють лише через нього, наприклад `transitionend` та `DOMContentLoaded`. Також `addEventListener` підтримує об’єкти-обробники подій. В цьому випадку викликається метод об’єкту `handleEvent`.
+Останній спосіб найбільш гнучкий, проте потрібно писати більше коду. Є кілька типів подій, які працюють лише через нього, наприклад `transitionend` та `DOMContentLoaded`. Також `addEventListener` підтримує об'єкти-обробники подій. В цьому випадку викликається метод об'єкту `handleEvent`.
 
-Не важливо, як ви призначаєте обробник, він отримує об’єкт події першим аргументом. Цей об’єкт містить подробиці про те, що сталося.
+Не важливо, як ви призначаєте обробник, він отримує об'єкт події першим аргументом. Цей об'єкт містить подробиці про те, що сталося.
 
 Ми вивчимо більше про події та їх типи у наступних розділах.
diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index c9c3f9bda..67202f9cf 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -39,7 +39,7 @@
 1. У самого `<p>`.
 2. Потім зовнішнього `<div>`.
 3. Потім зовнішнього `<form>`.
-4. І так далі вгору до об’єкта `document`.
+4. І так далі вгору до об'єкта `document`.
 
 ![](event-order-bubbling.svg)
 
@@ -216,7 +216,7 @@ elem.addEventListener("click", e => alert(2));
 - Потім обробники викликаються на самому цільовому елементі.
 - Потім подія спливає від `event.target` до кореня, викликаючи обробники, призначені з використанням `on<event>`, HTML-атрибутів та `addEventListener` без третього аргументу або з третім аргументом `false/{capture:false}`.
 
-Кожен обробник може отримати доступ до властивостей об’єкта `event`:
+Кожен обробник може отримати доступ до властивостей об'єкта `event`:
 
 - `event.target` - найглибший елемент, який спричинив подію.
 - `event.currentTarget` (=`this`) - поточний елемент, який обробляє подію (той, на якому є обробник).
diff --git a/2-ui/2-events/03-event-delegation/3-sortable-table/task.md b/2-ui/2-events/03-event-delegation/3-sortable-table/task.md
index c29bc8635..10b9352e9 100644
--- a/2-ui/2-events/03-event-delegation/3-sortable-table/task.md
+++ b/2-ui/2-events/03-event-delegation/3-sortable-table/task.md
@@ -14,7 +14,7 @@ Each `<th>` has the type in the attribute, like this:
     <tr>
 *!*
       <th data-type="number">Вік</th>
-      <th data-type="string">Ім’я</th>
+      <th data-type="string">Ім'я</th>
 */!*
     </tr>
   </thead>
diff --git a/2-ui/2-events/03-event-delegation/4-behavior-tooltip/task.md b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/task.md
index 31bbbad3f..ca9e41e78 100644
--- a/2-ui/2-events/03-event-delegation/4-behavior-tooltip/task.md
+++ b/2-ui/2-events/03-event-delegation/4-behavior-tooltip/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Створіть JS-код для поведінки спливаючої підказки.
 
-При наведенні миші на елемент з `data-tooltip`, підказка має з’явитися над ним і ховатися при переході на інший елемент.
+При наведенні миші на елемент з `data-tooltip`, підказка має з'явитися над ним і ховатися при переході на інший елемент.
 
 Приклад HTML з підказками:
 ```html
diff --git a/2-ui/2-events/03-event-delegation/article.md b/2-ui/2-events/03-event-delegation/article.md
index 66bcb6390..fb236a86a 100644
--- a/2-ui/2-events/03-event-delegation/article.md
+++ b/2-ui/2-events/03-event-delegation/article.md
@@ -83,7 +83,7 @@ function highlight(td) {
 
 ![](bagua-bubble.svg)
 
-В обробнику `table.onclick` ми повинні взяти `event.target` і з’ясувати, чи був клік всередині `<td>` чи ні.
+В обробнику `table.onclick` ми повинні взяти `event.target` і з'ясувати, чи був клік всередині `<td>` чи ні.
 
 Ось покращений код:
 
@@ -111,7 +111,7 @@ table.onclick = function(event) {
 
 Є й інші варіанти використання делегування подій.
 
-Скажімо, ми хочемо створити меню з кнопками «Зберегти», «Завантажити», «Пошук» і так далі. А ще є об’єкт з методами `save`, `load`, `search`... Як їх поєднати?
+Скажімо, ми хочемо створити меню з кнопками «Зберегти», «Завантажити», «Пошук» і так далі. А ще є об'єкт з методами `save`, `load`, `search`... Як їх поєднати?
 
 Перше, що спадає на думку -- це призначити окремий обробник кожній кнопці. Але є більш елегантне рішення. Ми можемо додати один обробник до всього меню та атрибути `data-action` до кожної кнопки відповідно до методів, які вони викликають:
 
@@ -161,7 +161,7 @@ table.onclick = function(event) {
 </script>
 ```
 
-Зауважте, що `this.onClick` прив’язаний до `this` у `(*)`. Це важливо, тому що інакше `this` в ньому посилатиметься на елемент DOM (`elem`), а не на об’єкт `Menu`, і `this[action]` буде не тим, який нам потрібен.
+Зауважте, що `this.onClick` прив'язаний до `this` у `(*)`. Це важливо, тому що інакше `this` в ньому посилатиметься на елемент DOM (`elem`), а не на об'єкт `Menu`, і `this[action]` буде не тим, який нам потрібен.
 
 Отже, які переваги дає нам тут делегування?
 
@@ -204,7 +204,7 @@ table.onclick = function(event) {
 Атрибутів із `data-counter` може бути скільки завгодно. Ми можемо в будь-який момент додати до HTML нові. Використовуючи делегування подій, ми фактично «розширили» HTML, додали атрибут, який описує нову поведінку.
 
 ```warn header="Завжди використовуйте метод `addEventListener` для обробників на рівні документу"
-Коли ми присвоюємо обробник події об’єкту `document`, ми завжди повинні використовувати `addEventListener`, а не `document.on<event>`, оскільки останній спричинить конфлікти: нові обробники перезапишуть старі.
+Коли ми присвоюємо обробник події об'єкту `document`, ми завжди повинні використовувати `addEventListener`, а не `document.on<event>`, оскільки останній спричинить конфлікти: нові обробники перезапишуть старі.
 
 Для реальних проєктів вважається нормальною наявність великої кількості обробників на `document`, встановлених різними частинами коду.
 ```
@@ -240,7 +240,7 @@ table.onclick = function(event) {
 
 Це дуже зручно -- не потрібно писати JavaScript для кожного такого елемента. Просто використовуйте поведінку. Обробник на рівні документа дозволяє працювати з будь-яким елементом сторінки. 
 
-Ми також можемо об’єднати кілька видів поведінки в одному елементі.
+Ми також можемо об'єднати кілька видів поведінки в одному елементі.
 
 Шаблон «поведінка» може бути альтернативою міні-фрагментам JavaScript.
 
@@ -259,7 +259,7 @@ table.onclick = function(event) {
 Переваги:
 
 ```compare
-+ Спрощує ініціалізацію та економить пам’ять: не потрібно додавати багато обробників.
++ Спрощує ініціалізацію та економить пам'ять: не потрібно додавати багато обробників.
 + Менше коду: під час додавання або видалення елементів не потрібно додавати/видаляти обробники.
 + Модифікації DOM: ми можемо масово додавати/видаляти елементи за допомогою `innerHTML` тощо.
 ```
diff --git a/2-ui/2-events/04-default-browser-action/article.md b/2-ui/2-events/04-default-browser-action/article.md
index cc4b2fb3c..d67cd8703 100644
--- a/2-ui/2-events/04-default-browser-action/article.md
+++ b/2-ui/2-events/04-default-browser-action/article.md
@@ -14,7 +14,7 @@
 
 Є два способи запобігти діям браузера:
 
-- Основний спосіб -- це використовувати об’єкт `event`. Існує метод `event.preventDefault()`.
+- Основний спосіб -- це використовувати об'єкт `event`. Існує метод `event.preventDefault()`.
 - Якщо обробник призначено за допомогою `on<event>` (а не `addEventListener`), повернення `false` спрацює так само.
 
 У цьому HTML після кліку на посилання навігація не відбувається, браузер нічого не робить:
@@ -94,7 +94,7 @@ menu.onclick = function(event) {
 
 ## Опція «пасивного» обробника
 
-Необов’язковий параметр `passive: true` для `addEventListener` сигналізує браузеру, що обробник не збирається викликати `preventDefault()`.
+Необов'язковий параметр `passive: true` для `addEventListener` сигналізує браузеру, що обробник не збирається викликати `preventDefault()`.
 
 Чому це може знадобитися?
 
@@ -113,7 +113,7 @@ menu.onclick = function(event) {
 
 Є цікавий варіант використання.
 
-Пам’ятаєте, в розділі <info:bubbling-and-capturing> ми говорили про `event.stopPropagation()` і чому припинення спливання -- це погано?
+Пам'ятаєте, в розділі <info:bubbling-and-capturing> ми говорили про `event.stopPropagation()` і чому припинення спливання -- це погано?
 
 Іноді замість цього ми можемо використовувати `event.defaultPrevented`, щоб повідомити іншим обробникам, що подія була оброблена.
 
@@ -131,7 +131,7 @@ menu.onclick = function(event) {
 
 Тепер, на додаток до цього контекстного меню, ми хотіли б реалізувати контекстне меню всього документа.
 
-Після кліку правою кнопкою миші має з’явитися найближче контекстне меню.
+Після кліку правою кнопкою миші має з'явитися найближче контекстне меню.
 
 ```html autorun height=80 no-beautify run
 <p>Правий клік, щоб відкрити контекстне меню документа</p>
@@ -203,15 +203,15 @@ menu.onclick = function(event) {
 Тепер теж все працює коректно. Якщо ми маємо вкладені елементи, і кожен з них має власне контекстне меню, це також спрацює. Просто не забудьте перевірити наявність `event.defaultPrevented` у кожному обробнику `contextmenu`.
 
 ```smart header="event.stopPropagation() та event.preventDefault()"
-Як ми чітко бачимо, `event.stopPropagation()` та `event.preventDefault()` (також відомий як `return false`) -- це два різні методи. Вони не пов’язані один з одним.
+Як ми чітко бачимо, `event.stopPropagation()` та `event.preventDefault()` (також відомий як `return false`) -- це два різні методи. Вони не пов'язані один з одним.
 ```
 
 ```smart header="Архітектура вкладених контекстних меню"
-Існують також альтернативні способи реалізації вкладених контекстних меню. Один з них -- це мати єдиний глобальний об’єкт з обробником для `document.oncontextmenu`, а також методами, які дозволяють нам зберігати в ньому інші обробники.
+Існують також альтернативні способи реалізації вкладених контекстних меню. Один з них -- це мати єдиний глобальний об'єкт з обробником для `document.oncontextmenu`, а також методами, які дозволяють нам зберігати в ньому інші обробники.
 
-Об’єкт буде ловити будь-який клік правою кнопкою миші, переглядати збережені обробники та запускати відповідний.
+Об'єкт буде ловити будь-який клік правою кнопкою миші, переглядати збережені обробники та запускати відповідний.
 
-Але тоді кожен фрагмент коду, якому буде потрібно контекстне меню, повинен знати про цей об’єкт і використовувати його замість власного обробника `contextmenu`.
+Але тоді кожен фрагмент коду, якому буде потрібно контекстне меню, повинен знати про цей об'єкт і використовувати його замість власного обробника `contextmenu`.
 ```
 
 ## Підсумки
diff --git a/2-ui/2-events/05-dispatch-events/article.md b/2-ui/2-events/05-dispatch-events/article.md
index ed36648a7..0ff3f2b5d 100644
--- a/2-ui/2-events/05-dispatch-events/article.md
+++ b/2-ui/2-events/05-dispatch-events/article.md
@@ -10,7 +10,7 @@
 
 Вбудовані класи подій утворюють ієрархію, подібну до класів елементів DOM. Корінь -- це вбудований клас [Event](https://dom.spec.whatwg.org/#events).
 
-Ми можемо створювати об’єкти `Event` на зразок цього:
+Ми можемо створювати об'єкти `Event` на зразок цього:
 
 ```js
 let event = new Event(type[, options]);
@@ -19,7 +19,7 @@ let event = new Event(type[, options]);
 Аргументи:
 
 - *type* -- тип події, рядок, як-от `"click"` або наш власний, наприклад, `"my-event"`.
-- *options* -- об’єкт з двома необов’язковими властивостями:
+- *options* -- об'єкт з двома необов'язковими властивостями:
   - `bubbles: true/false` -- якщо `true`, то подія спливає.
   - `cancelable: true/false` -- якщо `true`, то "типова дія" може бути попереджена. Пізніше ми побачимо, що це означає для користувацьких подій.
 
@@ -27,7 +27,7 @@ let event = new Event(type[, options]);
 
 ## dispatchEvent
 
-Після створення об’єкта події ми повинні "запустити" її на елементі за допомогою виклику `elem.dispatchEvent(event)`.
+Після створення об'єкта події ми повинні "запустити" її на елементі за допомогою виклику `elem.dispatchEvent(event)`.
 
 Потім обробники реагують на неї, як на звичайну подію браузера. Якщо подія була створена з прапором `bubbles`, вона спливає.
 
@@ -127,7 +127,7 @@ alert(event.clientX); // undefined, невідома властивість іг
 */!*
 ```
 
-Втім, ми можемо обійти це, призначивши `event.clientX=100` безпосередньо після створення об’єкта. Тож це питання зручності та дотримання правил. Події, створені браузером, завжди мають правильний тип.
+Втім, ми можемо обійти це, призначивши `event.clientX=100` безпосередньо після створення об'єкта. Тож це питання зручності та дотримання правил. Події, створені браузером, завжди мають правильний тип.
 
 Повний опис властивостей для різних події інтерфейсу користувача є в специфікації, наприклад, [MouseEvent](https://www.w3.org/TR/uievents/#mouseevent).
 
@@ -135,7 +135,7 @@ alert(event.clientX); // undefined, невідома властивість іг
 
 Для наших власних, абсолютно нових типів подій, таких як `"hello"`, ми повинні використовувати `new CustomEvent`. Технічно [CustomEvent](https://dom.spec.whatwg.org/#customevent) -- це те ж саме, що й `Event`, за одним винятком.
 
-У другий аргумент (об’єкт) ми можемо додати додаткову властивість `detail` для будь-якої спеціальної інформації, яку ми хочемо передати разом із подією.
+У другий аргумент (об'єкт) ми можемо додати додаткову властивість `detail` для будь-якої спеціальної інформації, яку ми хочемо передати разом із подією.
 
 Наприклад:
 
@@ -156,7 +156,7 @@ alert(event.clientX); // undefined, невідома властивість іг
 </script>
 ```
 
-Властивість `detail` може містити будь-які дані. Технічно ми могли б жити і без них, оскільки ми можемо призначити будь-які властивості звичайному об’єкту `new Event` після його створення. Але `CustomEvent` забезпечує спеціальне поле `detail`, щоб уникнути конфліктів з іншими властивостями події.
+Властивість `detail` може містити будь-які дані. Технічно ми могли б жити і без них, оскільки ми можемо призначити будь-які властивості звичайному об'єкту `new Event` після його створення. Але `CustomEvent` забезпечує спеціальне поле `detail`, щоб уникнути конфліктів з іншими властивостями події.
 
 Крім того, клас події описує яка саме це подія, і якщо вона користувацька, то ми повинні використовувати `CustomEvent`, щоб явно вказати на це. 
 
@@ -272,9 +272,9 @@ alert(event.clientX); // undefined, невідома властивість іг
 
 ## Підсумки
 
-Щоб створити подію з коду, нам спочатку потрібно створити об’єкт події.
+Щоб створити подію з коду, нам спочатку потрібно створити об'єкт події.
 
-Базовий конструктор `Event(name, options)` приймає довільне ім’я події та об’єкт параметрів із двома властивостями:
+Базовий конструктор `Event(name, options)` приймає довільне ім'я події та об'єкт параметрів із двома властивостями:
 - `bubbles: true` якщо подія має спливати.
 - `cancelable: true` якщо `event.preventDefault()` повинен працювати.
 
diff --git a/2-ui/3-event-details/1-mouse-events-basics/article.md b/2-ui/3-event-details/1-mouse-events-basics/article.md
index 22db5ea8e..9a1feb80a 100644
--- a/2-ui/3-event-details/1-mouse-events-basics/article.md
+++ b/2-ui/3-event-details/1-mouse-events-basics/article.md
@@ -49,7 +49,7 @@
 
 ## Кнопка миші
 
-Події, пов’язані з кліками, завжди мають властивість `button`, що дозволяє отримати точну кнопку миші.
+Події, пов'язані з кліками, завжди мають властивість `button`, що дозволяє отримати точну кнопку миші.
 
 Зазвичай ми не використовуємо її для подій `click` і `contextmenu`, оскільки перше відбувається лише при натисканні лівою кнопкою миші, а останнє -- лише при натисканні правою кнопкою миші.
 
diff --git a/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/task.md b/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/task.md
index 4600761fe..565f974be 100644
--- a/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/task.md
+++ b/2-ui/3-event-details/4-mouse-drag-and-drop/2-drag-heroes/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 У цьому завданні ви можете перевірити своє розуміння відразу декількох аспектів Drag'n'Drop і DOM.
 
-Зробіть так, щоб елементи з класом `draggable` -- можна було переносити мишкою. Як м’яч в цьому розділі.
+Зробіть так, щоб елементи з класом `draggable` -- можна було переносити мишкою. Як м'яч в цьому розділі.
 
 Вимоги до реалізації:
 
diff --git a/2-ui/3-event-details/4-mouse-drag-and-drop/article.md b/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
index 7b74bf5cb..7fa3594b0 100644
--- a/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
+++ b/2-ui/3-event-details/4-mouse-drag-and-drop/article.md
@@ -16,11 +16,11 @@ Drag'n'Drop -- відмінний спосіб поліпшити інтерфе
 
 1. На `mousedown` -- підготувати елемент до переміщення, якщо це необхідно (наприклад, створити його клон, додати до нього клас або щось ще).
 2. Потім, на `mousemove` перемістити його, змінивши значення `left/top` при позиціюванні `position: absolute`.
-3. На `mouseup` -- виконати усі дії, пов’язані із завершенням перенесення.
+3. На `mouseup` -- виконати усі дії, пов'язані із завершенням перенесення.
 
 Це основи. Пізніше ми розглянемо інші можливості, наприклад, підсвічування поточних елементів при перетяганні.
 
-Ось реалізація перенесення м’яча:
+Ось реалізація перенесення м'яча:
 
 ```js
 ball.onmousedown = function(event) { 
@@ -32,23 +32,23 @@ ball.onmousedown = function(event) {
   // щоб розташувати його відносно body
   document.body.append(ball);  
 
-  // центруємо м’яч за координатами (pageX, pageY)
+  // центруємо м'яч за координатами (pageX, pageY)
   function moveAt(pageX, pageY) {
     ball.style.left = pageX - ball.offsetWidth / 2 + 'px';
     ball.style.top = pageY - ball.offsetHeight / 2 + 'px';
   }
 
-  // переносимо наш абсолютно позиціюнованний м’яч під курсор
+  // переносимо наш абсолютно позиціюнованний м'яч під курсор
   moveAt(event.pageX, event.pageY);
 
   function onMouseMove(event) {
     moveAt(event.pageX, event.pageY);
   }
 
-  // (2) пересуваємо м’яч на mousemove
+  // (2) пересуваємо м'яч на mousemove
   document.addEventListener('mousemove', onMouseMove);
 
-  // (3) відпускаємо м’яч, видаляємо непотрібні обробники подій
+  // (3) відпускаємо м'яч, видаляємо непотрібні обробники подій
   ball.onmouseup = function() {
     document.removeEventListener('mousemove', onMouseMove);
     ball.onmouseup = null;
@@ -57,14 +57,14 @@ ball.onmousedown = function(event) {
 };
 ```
 
-Якщо ми запустимо код, то помітимо щось дивне. На початку `drag'n'drop` м’яч "виляє": ми починаємо перетягувати його "клон".
+Якщо ми запустимо код, то помітимо щось дивне. На початку `drag'n'drop` м'яч "виляє": ми починаємо перетягувати його "клон".
 
 ```online
 Приклад:
 
 [iframe src="ball" height=230]
 
-Спробуйте перенести м’яч мишкою і ви побачите вказану поведінку.
+Спробуйте перенести м'яч мишкою і ви побачите вказану поведінку.
 ```
 
 Все тому, що браузер має свій власний drag'n'drop, який автоматично запускається і вступає в конфлікт із нашим. Це відбувається саме для зображень та деяких інших елементів.
@@ -85,32 +85,32 @@ ball.ondragstart = function() {
 [iframe src="ball2" height=230]
 ```
 
-Ще одна деталь -- подія `mousemove` відстежується на `document`, а не на `ball`. З першого погляду здається, що миша завжди над м’ячем і обробник `mousemove` можна повісити на сам м’яч, а не на документ.
+Ще одна деталь -- подія `mousemove` відстежується на `document`, а не на `ball`. З першого погляду здається, що миша завжди над м'ячем і обробник `mousemove` можна повісити на сам м'яч, а не на документ.
 
-Але, як ми пам’ятаємо, подія `mousemove` виникає хоч і часто, але не для кожного пікселя. Тому через швидкий рух курсору може зіскочити з м’яча і виявитися де-небудь в середині документу (або навіть за межами вікна).
+Але, як ми пам'ятаємо, подія `mousemove` виникає хоч і часто, але не для кожного пікселя. Тому через швидкий рух курсору може зіскочити з м'яча і виявитися де-небудь в середині документу (або навіть за межами вікна).
 
 Ось чому ми повинні відстежувати `mousemove` на усьому `document`, щоб упіймати його у будь-якому разі.
 
 ## Правильне позиціювання
 
-У прикладах вище м’яч позиціонується так, що його центр опиняється під курсором миші:
+У прикладах вище м'яч позиціонується так, що його центр опиняється під курсором миші:
 
 ```js
 ball.style.left = pageX - ball.offsetWidth / 2 + 'px';
 ball.style.top = pageY - ball.offsetHeight / 2 + 'px';
 ```
 
-Непогано, але є побічний ефект. Щоб ініціювати перенесення, ми можемо натиснути(`mousedown`) у будь-якому місці кулі. Але якщо "узяти" його з краю, то м’яч несподівано "підстрибне", щоб стати по центру під курсором миші.
+Непогано, але є побічний ефект. Щоб ініціювати перенесення, ми можемо натиснути(`mousedown`) у будь-якому місці кулі. Але якщо "узяти" його з краю, то м'яч несподівано "підстрибне", щоб стати по центру під курсором миші.
 
 Було б краще, якби ми зберігали початковий зсув елементу відносно курсору.
 
-Наприклад, якщо ми "схопили" за край м’яча, то курсор повинен залишатися над краєм під час перенесення.
+Наприклад, якщо ми "схопили" за край м'яча, то курсор повинен залишатися над краєм під час перенесення.
 
 ![](ball_shift.svg)
 
 Давайте покращимо наш алгоритм:
 
-1. Коли користувач натискає на м’ячик (`mousedown`) - запам’ятаємо відстань від курсора миші до лівого верхнього кута м’яча в змінних `shiftX/shiftY`. Далі утримуватимемо цю відстань при пересуванні м’яча.
+1. Коли користувач натискає на м'ячик (`mousedown`) - запам'ятаємо відстань від курсора миші до лівого верхнього кута м'яча в змінних `shiftX/shiftY`. Далі утримуватимемо цю відстань при пересуванні м'яча.
 
     Щоб отримати цей зсув, ми можемо відняти координати:
 
@@ -120,11 +120,11 @@ ball.style.top = pageY - ball.offsetHeight / 2 + 'px';
     let shiftY = event.clientY - ball.getBoundingClientRect().top;
     ```
 
-2. Далі при перенесенні м’яча ми позиціонуємо його з тим же зсувом відносно курсора миші, таким чином:
+2. Далі при перенесенні м'яча ми позиціонуємо його з тим же зсувом відносно курсора миші, таким чином:
 
     ```js
     // onmousemove
-    // м’яч має position:absolute
+    // м'яч має position:absolute
     ball.style.left = event.pageX - *!*shiftX*/!* + 'px';
     ball.style.top = event.pageY - *!*shiftY*/!* + 'px';
     ```
@@ -145,7 +145,7 @@ ball.onmousedown = function(event) {
 
   moveAt(event.pageX, event.pageY);
 
-  // переносимо м’яч на координати (pageX, pageY)
+  // переносимо м'яч на координати (pageX, pageY)
   // додатково враховуючи початковий зсув відносно курсору миші
   function moveAt(pageX, pageY) {
     ball.style.left = pageX - *!*shiftX*/!* + 'px';
@@ -156,10 +156,10 @@ ball.onmousedown = function(event) {
     moveAt(event.pageX, event.pageY);
   }
 
-  // пересуваємо м’яч при mousemove
+  // пересуваємо м'яч при mousemove
   document.addEventListener('mousemove', onMouseMove);
 
-  // відпускаємо м’яч, видаляємо непотрібні обробники подій
+  // відпускаємо м'яч, видаляємо непотрібні обробники подій
   ball.onmouseup = function() {
     document.removeEventListener('mousemove', onMouseMove);
     ball.onmouseup = null;
@@ -178,11 +178,11 @@ ball.ondragstart = function() {
 [iframe src="ball3" height=230]
 ```
 
-Відмінність особливо помітна, якщо захопити м’яч за правий нижній кут. У попередньому прикладі м’ячик "стрибне" серединою під курсор, а в цьому -- плавно переноситиметься з поточної позиції.
+Відмінність особливо помітна, якщо захопити м'яч за правий нижній кут. У попередньому прикладі м'ячик "стрибне" серединою під курсор, а в цьому -- плавно переноситиметься з поточної позиції.
 
 ## Цілі перенесення (droppables)
 
-У попередніх прикладах м’яч можна було кинути просто де завгодно в межах вікна. На практиці ми зазвичай беремо один елемент і перетягуємо в іншій. Наприклад, "файл" в "папку" або щось ще.
+У попередніх прикладах м'яч можна було кинути просто де завгодно в межах вікна. На практиці ми зазвичай беремо один елемент і перетягуємо в іншій. Наприклад, "файл" в "папку" або щось ще.
 
 Абстрактно кажучи, ми беремо перетягуваний (draggable) елемент і поміщаємо його в інший елемент -- "ціль перенесення" (droppable).
 
@@ -213,7 +213,7 @@ ball.ondragstart = function() {
 <div style="background:red" onmouseover="alert('над червоним!')"></div>
 ```
 
-Те ж саме з перетягуючим елементом. М’яч завжди знаходиться поверх інших елементів, тому події спрацьовують на ньому. Які б обробники ми не встановили на нижні елементи, вони не будуть виконані.
+Те ж саме з перетягуючим елементом. М'яч завжди знаходиться поверх інших елементів, тому події спрацьовують на ньому. Які б обробники ми не встановили на нижні елементи, вони не будуть виконані.
 
 Ось чому початкова ідея встановити обробники на потенційні цілі перенесення не спрацює на практиці. Обробники не будуть викликатися.
 
@@ -221,19 +221,19 @@ ball.ondragstart = function() {
 
 Існує метод `document.elementFromPoint(clientX, clientY)`. Він повертає найбільш глибоко вкладений елемент за заданими координатами вікна (або `null`, якщо зазначені координати знаходяться за межами вікна). Якщо в одних і тих самих координатах є кілька елементів, що перекриваються, повертається найвищий.
 
-Ми можемо використати його, щоб з будь-якого обробника подій миші з’ясувати, над якою ми потенційною ціллю перенесення, ось так:
+Ми можемо використати його, щоб з будь-якого обробника подій миші з'ясувати, над якою ми потенційною ціллю перенесення, ось так:
 
 ```js
 // всередині обробника події миші
 ball.hidden = true; // (*) ховаємо елемент який переносимо
 
 let elemBelow = document.elementFromPoint(event.clientX, event.clientY);
-// elemBelow -- елемент під м’ячем (можлива ціль перенесення)
+// elemBelow -- елемент під м'ячем (можлива ціль перенесення)
 
 ball.hidden = false;
 ```
 
-Зауважимо, нам потрібно заховати м’яч перед викликом функції `(*)`. В іншому випадку за цими координатами ми будемо отримувати м’яч, адже це і є елемент безпосередньо під курсором: `elemBelow=ball`. Так що ми ховаємо його і одразу показуємо.
+Зауважимо, нам потрібно заховати м'яч перед викликом функції `(*)`. В іншому випадку за цими координатами ми будемо отримувати м'яч, адже це і є елемент безпосередньо під курсором: `elemBelow=ball`. Так що ми ховаємо його і одразу показуємо.
 
 Ми можемо використовувати цей код для перевірки того, над яким елементом ми "летимо", в будь-який час. І обробити закінчення перенесення, коли воно станеться.
 
@@ -250,7 +250,7 @@ function onMouseMove(event) {
   let elemBelow = document.elementFromPoint(event.clientX, event.clientY);
   ball.hidden = false;
 
-  // подія mousemove може статися і коли курсор за межами вікна (м’яч перетягнули за межі екрану)
+  // подія mousemove може статися і коли курсор за межами вікна (м'яч перетягнули за межі екрану)
   // якщо clientX/clientY за межами вікна, elementFromPoint поверне null
   if (!elemBelow) return;
 
@@ -276,7 +276,7 @@ function onMouseMove(event) {
 }
 ```
 
-У наведеному нижче прикладі, коли м’яч перетягується через футбольні ворота, ворота підсвічуються.
+У наведеному нижче прикладі, коли м'яч перетягується через футбольні ворота, ворота підсвічуються.
 
 [codetabs height=250 src="ball4"]
 
@@ -289,7 +289,7 @@ function onMouseMove(event) {
 Ключові ідеї:
 
 1. Потік подій: `ball.mousedown` -> `document.mousemove` -> `ball.mouseup` (не забудьте скасувати браузерний `ondragstart`).
-2. На початку перетягування -- запам’ятовуємо початкове зміщення курсору щодо елемента: `shiftX/shiftY` і зберігаємо його при перетягуванні.
+2. На початку перетягування -- запам'ятовуємо початкове зміщення курсору щодо елемента: `shiftX/shiftY` і зберігаємо його при перетягуванні.
 3. Виявляємо потенційні цілі перенесення під курсором за допомогою `document.elementFromPoint`.
 
 На цій основі можна зробити багато чого.
diff --git a/2-ui/3-event-details/6-pointer-events/article.md b/2-ui/3-event-details/6-pointer-events/article.md
index 504c5e8cc..8d0f55a59 100644
--- a/2-ui/3-event-details/6-pointer-events/article.md
+++ b/2-ui/3-event-details/6-pointer-events/article.md
@@ -16,7 +16,7 @@
 
     Але все-таки цього було недостатньо, оскільки є багато інших пристроїв, наприклад ручок, які мають свої особливості. Крім того, код, який прослуховує як події дотику, так і миші, досить громіздкий.
 
-- Щоб розв’язати ці проблеми, було введено новий стандарт Pointer Events. Він забезпечує єдиний набір подій для всіх видів вказівних пристроїв.
+- Щоб розв'язати ці проблеми, було введено новий стандарт Pointer Events. Він забезпечує єдиний набір подій для всіх видів вказівних пристроїв.
 
 На цей час специфікація [Pointer Events Level 2](https://www.w3.org/TR/pointerevents2/) підтримується в усіх основних браузерах, тоді як новіша версія [Pointer Events Level 3](https://w3c.github.io/pointerevents/) знаходиться в розробці і в основному сумісна з Pointer Events другого рівня.
 
@@ -88,7 +88,7 @@
 
 Зверніть увагу: `pointerId` призначається не всьому пристрою, а кожному дотику пальця. Якщо ми використовуємо 5 пальців, щоб одночасно торкнутися екрана, у нас буде 5 подій `pointerdown`, кожна зі своїми відповідними координатами та іншим `pointerId`.
 
-Події, пов’язані з першим пальцем, завжди мають значення `isPrimary=true`.
+Події, пов'язані з першим пальцем, завжди мають значення `isPrimary=true`.
 
 Ми можемо відстежувати кілька пальців, використовуючи їх `pointerId`. Коли користувач рухає, а потім прибирає палець, ми отримуємо події `pointermove` та `pointerup` з тим же `pointerId`, що й у `pointerdown`.
 
@@ -111,7 +111,7 @@
 
 Ми продемонструємо `pointercancel` на практичному прикладі, щоб побачити, як він впливає на нас.
 
-Скажімо, ми впроваджуємо drag'n'drop для м’яча, як на початку статті <info:mouse-drag-and-drop>.
+Скажімо, ми впроваджуємо drag'n'drop для м'яча, як на початку статті <info:mouse-drag-and-drop>.
 
 Ось хід дій користувача та відповідні події:
 
@@ -120,7 +120,7 @@
 2) Потім він починає рухати вказівник (перетягуючи таким чином зображення) 
     - `pointermove` спрацьовує, можливо, кілька разів
 3) І тоді відбувається сюрприз! Браузер має вбудовану підтримку drag'n'drop для зображень, яка запускається та бере на себе процес drag'n'drop, таким чином генеруючи подію `pointercancel`.
-    - Тепер браузер самостійно обробляє перетягування зображення. Користувач може навіть перетягнути зображення м’яча з браузера, у свою поштову програму або файловий менеджер.
+    - Тепер браузер самостійно обробляє перетягування зображення. Користувач може навіть перетягнути зображення м'яча з браузера, у свою поштову програму або файловий менеджер.
     - Для нас більше немає подій `pointermove`.
 
 Таким чином, проблема полягає в тому, що браузер "викрадає" взаємодію: `pointercancel` запускається на початку процесу "перетягування" і події  `pointermove` більше не генеруються.
@@ -140,7 +140,7 @@
 1. Запобігти нативному drag'n'drop:
     - Ми можемо зробити це, встановивши `ball.ondragstart = () => false`, як описано в статті <info:mouse-drag-and-drop>.
     - Це добре працює для подій миші.
-2. Для сенсорних пристроїв існують інші дії браузера, пов’язані з дотиком (крім перетягування). Щоб уникнути проблем і з ними: 
+2. Для сенсорних пристроїв існують інші дії браузера, пов'язані з дотиком (крім перетягування). Щоб уникнути проблем і з ними: 
     - Запобігти їм, встановивши `#ball { touch-action: none }` у CSS
     - Тоді наш код почне працювати на сенсорних пристроях.
 
@@ -154,7 +154,7 @@
 Як бачите, `pointercancel` більше немає.
 ```
 
-Тепер ми можемо додати код для фактичного переміщення м’яча, і наш drag'n'drop працюватиме для пристроїв миші та сенсорних пристроїв.
+Тепер ми можемо додати код для фактичного переміщення м'яча, і наш drag'n'drop працюватиме для пристроїв миші та сенсорних пристроїв.
 
 ## Захоплення вказівника
 
@@ -163,11 +163,11 @@
 Ідея дуже проста, але спочатку може здатися досить дивною, оскільки нічого подібного для будь-якого іншого типу події не існує.
 
 Основним методом є:
-- `elem.setPointerCapture(pointerId)` -- зв’язує події із заданим `pointerId` з `elem`. Після виклику всі події вказівника з однаковим `pointerId` матимуть `elem` як ціль (ніби вони відбулися на `elem`), незалежно від того, де в документі вони дійсно відбулися.
+- `elem.setPointerCapture(pointerId)` -- зв'язує події із заданим `pointerId` з `elem`. Після виклику всі події вказівника з однаковим `pointerId` матимуть `elem` як ціль (ніби вони відбулися на `elem`), незалежно від того, де в документі вони дійсно відбулися.
 
 Іншими словами, `elem.setPointerCapture(pointerId)` перенацілює всі наступні події з заданим `pointerId` на `elem`.
 
-Прив’язка усувається:
+Прив'язка усувається:
 - автоматично, коли відбуваються події `pointerup` або `pointercancel`,
 - автоматично, коли `elem` видаляється з документа,
 - коли викликається `elem.releasePointerCapture(pointerId)`.
@@ -200,15 +200,15 @@
 
 У рішенні на основі подій миші, щоб відстежувати всі рухи вказівника, включно з тим, коли він переміщується вище/нижче `thumb`, ми повинні були призначити обробник події `mousemove` для всього `document`.
 
-Однак це не "найчистіше" рішення. Одна з проблем полягає в тому, що коли користувач переміщує вказівник по документу, він може запускати обробники подій (наприклад, `mouseover`) на деяких інших елементах, викликати абсолютно не пов’язані функції інтерфейсу користувача, а ми цього не хочемо.
+Однак це не "найчистіше" рішення. Одна з проблем полягає в тому, що коли користувач переміщує вказівник по документу, він може запускати обробники подій (наприклад, `mouseover`) на деяких інших елементах, викликати абсолютно не пов'язані функції інтерфейсу користувача, а ми цього не хочемо.
 
 Це місце, де `setPointerCapture` вступає в гру.
 
 - Ми можемо викликати `thumb.setPointerCapture(event.pointerId)` в обробнику `pointerdown`,
 - Тоді майбутні події вказівника до `pointerup/cancel` будуть перенацілені на `thumb`.
-- Коли відбувається `pointerup` (перетягування завершено), прив’язка видаляється автоматично, нам не потрібно перейматись за це.
+- Коли відбувається `pointerup` (перетягування завершено), прив'язка видаляється автоматично, нам не потрібно перейматись за це.
 
-Тому, навіть якщо користувач переміщує вказівник по всьому документу, обробники подій будуть викликатися на `thumb`. Проте, властивості координат об’єктів події, такі як `clientX/clientY`, залишаться правильними - захоплення впливає лише на `target/currentTarget`.
+Тому, навіть якщо користувач переміщує вказівник по всьому документу, обробники подій будуть викликатися на `thumb`. Проте, властивості координат об'єктів події, такі як `clientX/clientY`, залишаться правильними - захоплення впливає лише на `target/currentTarget`.
 
 Ось основний код:
 
@@ -253,14 +253,14 @@ thumb.onpointerdown = function(event) {
 
 
 Зрештою, захоплення вказівника дає нам дві переваги:
-1. Код стає чистішим, оскільки нам більше не потрібно додавати/видаляти обробники всього `document`. Прив’язка прибирається автоматично..
+1. Код стає чистішим, оскільки нам більше не потрібно додавати/видаляти обробники всього `document`. Прив'язка прибирається автоматично..
 2. Якщо в документі є інші обробники подій вказівника, вони не будуть випадково ініційовані вказівником, коли користувач перетягує повзунок.
 
 ### Події захоплення вказівника
 
 Тут для повноти слід згадати ще одну річ.
 
-Існують дві події, пов’язані із захопленням вказівника:
+Існують дві події, пов'язані із захопленням вказівника:
 
 - `gotpointercapture` спрацьовує, коли елемент використовує `setPointerCapture` для включення захоплення.
 - `lostpointercapture` запускається, коли відбувається звільнення від захоплення: або явно за допомогою виклику `releasePointerCapture`, або автоматично під час `pointerup`/`pointercancel`.
diff --git a/2-ui/3-event-details/7-keyboard-events/article.md b/2-ui/3-event-details/7-keyboard-events/article.md
index d6623732e..0eae2efde 100644
--- a/2-ui/3-event-details/7-keyboard-events/article.md
+++ b/2-ui/3-event-details/7-keyboard-events/article.md
@@ -28,7 +28,7 @@
 
 ### event.code та event.key
 
-Властивість `key` об’єкта події дозволяє отримати символ, а властивість `code` об’єкта події дозволяє отримати "фізичний код клавіші".
+Властивість `key` об'єкта події дозволяє отримати символ, а властивість `code` об'єкта події дозволяє отримати "фізичний код клавіші".
 
 Наприклад, ту саму клавішу `key:Z` можна натискати з або без клавіші `key:Shift`. Це дає нам два різних символи: малий `z` і великий `Z`.
 
@@ -107,7 +107,7 @@ document.addEventListener('keydown', function(event) {
 
 Для надійного відстеження символів, що залежать від розкладки, `event.key` може бути кращим рішенням.
 
-З іншого боку, `event.code` має перевагу, бо залишається завжди однаковим, прив’язаним до місця розташування фізичної клавіші, навіть якщо відвідувач змінює мову. Тому гарячі клавіші, які покладаються на нього, працюють добре навіть у разі перемикання мови.
+З іншого боку, `event.code` має перевагу, бо залишається завжди однаковим, прив'язаним до місця розташування фізичної клавіші, навіть якщо відвідувач змінює мову. Тому гарячі клавіші, які покладаються на нього, працюють добре навіть у разі перемикання мови.
 
 Чи хочемо ми обробляти клавіші, що залежать від розкладки? Тоді `event.key` -- це вихід.
 
@@ -117,7 +117,7 @@ document.addEventListener('keydown', function(event) {
 
 Якщо клавіша натискається досить довго, вона починає автоматично повторюватися: `keydown` запускається знову і знову, а потім, коли вона відпускається, ми нарешті отримуємо `keyup`. Таким чином, це нормально мати багато `keydown` і один `keyup`.
 
-Для подій, ініційованих автоповтором, об’єкт події має властивість `event.repeat`, встановлену на `true`.
+Для подій, ініційованих автоповтором, об'єкт події має властивість `event.repeat`, встановлену на `true`.
 
 
 ## Типові дії
@@ -126,7 +126,7 @@ document.addEventListener('keydown', function(event) {
 
 Наприклад:
 
-- На екрані з’являється символ (найбільш очевидний результат).
+- На екрані з'являється символ (найбільш очевидний результат).
 - Символ видалено (`key:Delete` клавіша).
 - Сторінка прокручується (`key:PageDown` клавіша).
 - Браузер відкриває діалогове вікно "Зберегти сторінку". (`key:Ctrl+S`)
@@ -147,7 +147,7 @@ function checkPhoneKey(key) {
 
 Обробник `onkeydown` використовує тут `checkPhoneKey` для перевірки натиснення клавіші. Якщо вона валідна (від `0..9` або з `+-()`), обробник повертає `true`, інакше `false`.
 
-Як ми знаємо, значення `false`, що повертається з обробника подій та присвоєне за допомогою властивості DOM або атрибута, як-от вище, запобігає типовій дії. Саме тому для клавіш, які не проходять тест, у `<input>` нічого не з’являється. (Повернуте значення `true` ні на що не впливає, має значення лише повернення `false`)
+Як ми знаємо, значення `false`, що повертається з обробника подій та присвоєне за допомогою властивості DOM або атрибута, як-от вище, запобігає типовій дії. Саме тому для клавіш, які не проходять тест, у `<input>` нічого не з'являється. (Повернуте значення `true` ні на що не впливає, має значення лише повернення `false`)
 
 Зверніть увагу, що спеціальні клавіші, такі як `key:Backspace`, `key:Left`, `key:Right`, не працюють у полі для введення. Це побічний ефект суворого фільтра `checkPhoneKey`. Ці клавіші змушують її повертати `false`.
 
@@ -171,7 +171,7 @@ function checkPhoneKey(key) {
 
 ## Застарілий код
 
-У минулому була подія `keypress`, а також `keyCode`, `charCode`, `which` властивості об’єкта події.
+У минулому була подія `keypress`, а також `keyCode`, `charCode`, `which` властивості об'єкта події.
 
 Під час роботи з ними було так багато несумісностей у браузерах, що у розробників специфікації не було іншого виходу, окрім як відмовитися від усіх них і створити нові, сучасні події (описані вище в цьому розділі). Старий код все ще працює, оскільки браузери продовжують підтримувати його, але більше немає потреби використовувати його.
 
diff --git a/2-ui/3-event-details/8-onscroll/2-updown-button/task.md b/2-ui/3-event-details/8-onscroll/2-updown-button/task.md
index e533fcf63..eabfdaddd 100644
--- a/2-ui/3-event-details/8-onscroll/2-updown-button/task.md
+++ b/2-ui/3-event-details/8-onscroll/2-updown-button/task.md
@@ -8,7 +8,7 @@ importance: 5
 
 Вона має працювати так:
 - Поки сторінка не прокручена принаймні на висоту вікна -- вона невидима.
-- Якщо сторінка прокручена нижче висоти вікна, у верхньому лівому куті з’являється стрілка "вгору". Якщо сторінку прокрутити назад, вона зникне.
+- Якщо сторінка прокручена нижче висоти вікна, у верхньому лівому куті з'являється стрілка "вгору". Якщо сторінку прокрутити назад, вона зникне.
 - При натисканні стрілки сторінка прокручується вгору.
 
 Ось так (верхній лівий кут, прокрутіть, щоб побачити):
diff --git a/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md b/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
index a5cb5983e..2b98165df 100644
--- a/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
+++ b/2-ui/3-event-details/8-onscroll/3-load-visible-img/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Завантаження видимих зображень
 
-Припустимо, у нас є клієнт з низькою швидкістю з’єднання, і ми хочемо заощадити його мобільний трафік.
+Припустимо, у нас є клієнт з низькою швидкістю з'єднання, і ми хочемо заощадити його мобільний трафік.
 
 З цією метою ми вирішуємо не показувати зображення відразу, а замінити їх заповнювачами, наприклад:
 
diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 50e0ceef8..2bde342af 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -8,7 +8,7 @@
 
 Форми в документі є членами спеціальної колекції `document.forms`.
 
-Це так звана *"іменована колекція"*: щоб отримати форму ми можемо використовувати як її ім’я, так і порядковий номер у документі.
+Це так звана *"іменована колекція"*: щоб отримати форму ми можемо використовувати як її ім'я, так і порядковий номер у документі.
 
 ```js no-beautify
 document.forms.my; // форма з іменем "my" (name="my")
@@ -36,7 +36,7 @@ document.forms[0]; // перша форма в документі
 </script>
 ```
 
-У колекції може бути кілька елементів з однаковим ім’ям (`name`). Це типово для перемикачів (radio buttons) та чекбоксів (checkboxes).
+У колекції може бути кілька елементів з однаковим ім'ям (`name`). Це типово для перемикачів (radio buttons) та чекбоксів (checkboxes).
 
 В такому випадку `form.elements[name]` -- це *колекція*. Наприклад:
 
@@ -94,7 +94,7 @@ alert(ageElems[0]); // [object HTMLInputElement]
 
 Іншими словами, замість `form.elements.login` ми можемо написати `form.login`.
 
-Такий варіант також працює, але є незначна проблема: якщо ми отримуємо доступ до елемента, а потім змінюємо його ім’я (`name`), то він все ще буде доступний під старим ім’ям (а також під новим).
+Такий варіант також працює, але є незначна проблема: якщо ми отримуємо доступ до елемента, а потім змінюємо його ім'я (`name`), то він все ще буде доступний під старим ім'ям (а також під новим).
 
 Це легко побачити на прикладі:
 
@@ -106,9 +106,9 @@ alert(ageElems[0]); // [object HTMLInputElement]
 <script>
   alert(form.elements.login == form.login); // true, це один і той самий <input>
 
-  form.login.name = "username"; // змінюємо ім’я поля вводу
+  form.login.name = "username"; // змінюємо ім'я поля вводу
 
-  // form.elements оновив ім’я:
+  // form.elements оновив ім'я:
   alert(form.elements.login); // undefined
   alert(form.elements.username); // input
 
@@ -237,7 +237,7 @@ input.checked = true; // для чекбокса або перемикача (ra
 option = new Option(text, value, defaultSelected, selected);
 ```
 
-Цей синтаксис необов’язковий. Ми можемо використати `document.createElement('option')` і встановити атрибути вручну. Однак те саме можна зробити коротше, тому ось параметри:
+Цей синтаксис необов'язковий. Ми можемо використати `document.createElement('option')` і встановити атрибути вручну. Однак те саме можна зробити коротше, тому ось параметри:
 
 - `text` -- текст всередині опції,
 - `value` -- значення опції,
@@ -284,7 +284,7 @@ let option = new Option("Текст", "value", true, true);
 : Отримати форму можна через `document.forms[name/index]`.
 
 `form.elements`  
-: Елементи форми можна отримати за допомогою `form.elements[ім’я/індекс]`, або можна використовувати лише `form[name/index]`. Властивість `elements` також доступна для `<fieldset>`.
+: Елементи форми можна отримати за допомогою `form.elements[ім'я/індекс]`, або можна використовувати лише `form[name/index]`. Властивість `elements` також доступна для `<fieldset>`.
 
 `element.form`
 : Елементи посилаються на свою форму через властивість `form`.
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 83b7c5a42..04f3cccc4 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
@@ -8,6 +8,6 @@ importance: 5
 
 Текстова область дозволяє редагувати HTML всередині `<div>`.
 
-Коли користувач натискає `key:Enter` або `<textarea>` втрачає фокус, тоді знову з’являється `<div>`, який містить в собі HTML введений в `<textarea>`.
+Коли користувач натискає `key:Enter` або `<textarea>` втрачає фокус, тоді знову з'являється `<div>`, який містить в собі HTML введений в `<textarea>`.
 
 [demo src="solution"]
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 14ddc51e8..a2848596b 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
@@ -6,8 +6,8 @@ importance: 5
 
 Створіть таблицю, клітини якої можна було б редагувати клікнувши на них.
 
-- По кліку -- в клітині з’являється `<textarea>`, в якій можна редагувати вміст в форматі HTML. Висота та ширина клітини при цьому не змінюється.
-- Кнопки ЗГОДА та ВІДМІНА з’являються внизу клітини щоб підтвердити/відмінити зміни.
+- По кліку -- в клітині з'являється `<textarea>`, в якій можна редагувати вміст в форматі HTML. Висота та ширина клітини при цьому не змінюється.
+- Кнопки ЗГОДА та ВІДМІНА з'являються внизу клітини щоб підтвердити/відмінити зміни.
 - Одночасно можна редагувати лише одну клітину. Поки `<td>` в "режимі редагування", кліки на інших клітинах ігноруються.
 - В талиці може бути багато клітин. Використовуйте делегування подій.
 
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 d82f16f95..48274c9c9 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -162,7 +162,7 @@
 ```html autorun height=80
 <!-- додати класс при фокусуванні на формі -->
 <form *!*onfocus="this.className='focused'"*/!*>
-  <input type="text" name="name" value="Ім’я">
+  <input type="text" name="name" value="Ім'я">
   <input type="text" name="surname" value="Прізвище">
 </form>
 
@@ -202,7 +202,7 @@
 
 ```html autorun height=80
 <form id="form">
-  <input type="text" name="name" value="Ім’я">
+  <input type="text" name="name" value="Ім'я">
   <input type="text" name="surname" value="Прізвище">
 </form>
 
diff --git a/2-ui/4-forms-controls/4-forms-submit/article.md b/2-ui/4-forms-controls/4-forms-submit/article.md
index d43252d9f..efc28de0d 100644
--- a/2-ui/4-forms-controls/4-forms-submit/article.md
+++ b/2-ui/4-forms-controls/4-forms-submit/article.md
@@ -28,7 +28,7 @@
 </form>
 ```
 
-````smart header="Зв’язок між `submit` та `click`"
+````smart header="Зв'язок між `submit` та `click`"
 Коли форма надсилається за допомогою `key:Enter` у полі введення, запускається подія `click` на `<input type="submit">`.
 
 Це досить смішно, тому що кліку взагалі не було.
@@ -47,7 +47,7 @@
 
 Щоб надіслати форму на сервер вручну, ми можемо викликати `form.submit()`.
 
-Тоді подія `submit` не генерується. Передбачається, що якщо програміст викликає `form.submit()`, то сценарій вже здійснив всю пов’язану обробку.
+Тоді подія `submit` не генерується. Передбачається, що якщо програміст викликає `form.submit()`, то сценарій вже здійснив всю пов'язану обробку.
 
 Іноді це використовується для створення та надсилання форми вручну, наприклад:
 
diff --git a/2-ui/5-loading/01-onload-ondomcontentloaded/article.md b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
index c8e327571..d32fb3de2 100644
--- a/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
+++ b/2-ui/5-loading/01-onload-ondomcontentloaded/article.md
@@ -17,7 +17,7 @@
 
 ## DOMContentLoaded
 
-Подія `DOMContentLoaded` відбувається на об’єкті `document`.
+Подія `DOMContentLoaded` відбувається на об'єкті `document`.
 
 Ми повинні використовувати `addEventListener`, щоб перехопити її:
 
@@ -55,7 +55,7 @@ document.addEventListener("DOMContentLoaded", ready);
 
 Коли браузер обробляє HTML-документ і зустрічає тег `<script>`, його потрібно виконати, перш ніж продовжити створення DOM. Це запобіжний захід, оскільки сценарії можуть захотіти змінити DOM і навіть `document.write` в нього, тому `DOMContentLoaded` має зачекати.
 
-Отже, DOMContentLoaded обов’язково відбувається після таких скриптів:
+Отже, DOMContentLoaded обов'язково відбувається після таких скриптів:
 
 ```html run
 <script>
@@ -101,14 +101,14 @@ document.addEventListener("DOMContentLoaded", ready);
 
 Firefox, Chrome і Opera автоматично заповнюють форми на `DOMContentLoaded`.
 
-Наприклад, якщо на сторінці є форма з логіном та паролем, і браузер запам’ятав значення, то на `DOMContentLoaded` він може спробувати їх автоматично заповнити (якщо це схвалено користувачем).
+Наприклад, якщо на сторінці є форма з логіном та паролем, і браузер запам'ятав значення, то на `DOMContentLoaded` він може спробувати їх автоматично заповнити (якщо це схвалено користувачем).
 
 Тож якщо `DOMContentLoaded` відкладається довгим завантаженням скриптів, то автозаповнення також чекає. Мабуть, ви бачили, що на деяких сайтах (якщо ви використовуєте автозаповнення браузера) -- поля логіна/паролю не заповнюються автоматично негайно, а є затримка до повного завантаження сторінки. Фактично це затримка до події `DOMContentLoaded`.
 
 
 ## window.onload [#window-onload]
 
-Подія `load` для об’єкта `window` запускається, коли завантажується вся сторінка, включаючи стилі, зображення та інші ресурси. Ця подія доступна через властивість `onload`.
+Подія `load` для об'єкта `window` запускається, коли завантажується вся сторінка, включаючи стилі, зображення та інші ресурси. Ця подія доступна через властивість `onload`.
 
 Наведений нижче приклад правильно показує розміри зображень, тому що `window.onload` чекає на всі зображення:
 
@@ -127,7 +127,7 @@ Firefox, Chrome і Opera автоматично заповнюють форми
 
 ## window.onunload
 
-Коли відвідувач залишає сторінку, у `window` запускається подія `unload`. Ми можемо зробити щось, що не передбачає затримки, наприклад закрити пов’язані спливаючі вікна.
+Коли відвідувач залишає сторінку, у `window` запускається подія `unload`. Ми можемо зробити щось, що не передбачає затримки, наприклад закрити пов'язані спливаючі вікна.
 
 Помітним винятком є надсилання аналітики.
 
@@ -141,7 +141,7 @@ Firefox, Chrome і Opera автоматично заповнюють форми
 
 Ось як ним користуватися:
 ```js
-let analyticsData = { /* об’єкт із зібраними даними */ };
+let analyticsData = { /* об'єкт із зібраними даними */ };
 
 window.addEventListener("unload", function() {
   navigator.sendBeacon("/analytics", JSON.stringify(analyticsData));
@@ -149,7 +149,7 @@ window.addEventListener("unload", function() {
 ```
 
 - Запит надсилається як POST.
-- Ми можемо надсилати не тільки рядок, а й форми та інші формати, як описано в главі <info:fetch>, але зазвичай це рядковий об’єкт.
+- Ми можемо надсилати не тільки рядок, а й форми та інші формати, як описано в главі <info:fetch>, але зазвичай це рядковий об'єкт.
 - Розмір даних обмежений 64 Кб.
 
 Коли запит `sendBeacon` завершено, браузер, ймовірно, вже залишив документ, тому немає можливості отримати відповідь сервера (яка зазвичай порожня для аналітики).
@@ -247,7 +247,7 @@ console.log(document.readyState);
 document.addEventListener('readystatechange', () => console.log(document.readyState));
 ```
 
-Подія `readystatechange` є альтернативною механікою відстеження стану завантаження документа, вона з’явилася давно. У наш час використовується рідко.
+Подія `readystatechange` є альтернативною механікою відстеження стану завантаження документа, вона з'явилася давно. У наш час використовується рідко.
 
 Давайте для повноти подивимося повний перебіг подій.
 
diff --git a/2-ui/5-loading/02-script-async-defer/article.md b/2-ui/5-loading/02-script-async-defer/article.md
index 8d98427b6..08aa350ec 100644
--- a/2-ui/5-loading/02-script-async-defer/article.md
+++ b/2-ui/5-loading/02-script-async-defer/article.md
@@ -31,7 +31,7 @@
 
 Але це рішення далеко не ідеальне. Наприклад, браузер помічає скрипт (і може почати його завантаження) лише після того, як повністю завантажить HTML-документ. Для великих документів HTML це може спричинити помітну затримку.
 
-Такі речі невидимі для людей, які використовують дуже швидкі з’єднання, але багато людей у світі все ще мають низьку швидкість Інтернету та використовують далеко не ідеальне мобільне інтернет-з’єднання.
+Такі речі невидимі для людей, які використовують дуже швидкі з'єднання, але багато людей у світі все ще мають низьку швидкість Інтернету та використовують далеко не ідеальне мобільне інтернет-з'єднання.
 
 На щастя, є два атрибути `<script>`, які вирішують нашу проблему: `defer` і `async`.
 
@@ -69,7 +69,7 @@
 <p>...вміст після скриптів...</p>
 ```
 
-1. Вміст сторінки з’являється негайно.
+1. Вміст сторінки з'являється негайно.
 2. Обробник події `DOMContentLoaded` чекає на відкладений скрипт. Він запускається лише тоді, коли скрипт буде завантажено та виконано.
 
 **Відкладені скрипти зберігають відносний порядок, як і звичайні скрипти.**
@@ -122,7 +122,7 @@
 <p>...вміст після скриптів...</p>
 ```
 
-- Вміст сторінки з’являється відразу: `async` не блокує його.
+- Вміст сторінки з'являється відразу: `async` не блокує його.
 - `DOMContentLoaded` може відбуватися як до, так і після `async`, тут немає гарантій.
 - Менший скрипт `small.js` йде другим, але, ймовірно, завантажується перед `long.js`, тому `small.js` запускається першим. Хоча, можливо, `long.js` завантажується спочатку, якщо він кешується, то він запускається першим. Іншими словами, асинхронні сценарії виконуються в порядку "першим завантажився -- першим виконався".
 
diff --git a/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
index a0878f655..95ceb5614 100644
--- a/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
+++ b/2-ui/5-loading/03-onload-onerror/1-load-img-callback/task.md
@@ -13,7 +13,7 @@ let img = document.createElement('img');
 img.src = 'my.jpg';
 ```
 
-Браузер починає завантажувати зображення і запам’ятовує його в кеші. Пізніше, коли те саме зображення з’являється в документі (незалежно від того, як), воно з’являється негайно.
+Браузер починає завантажувати зображення і запам'ятовує його в кеші. Пізніше, коли те саме зображення з'являється в документі (незалежно від того, як), воно з'являється негайно.
 
 **Створіть функцію `preloadImages(sources, callback)`, яка завантажує всі зображення з масиву `sources` і, коли буде готова, запускає `callback`.**
 
diff --git a/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md b/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
index 2c77caa7f..748aa3de5 100644
--- a/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
+++ b/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
@@ -40,10 +40,10 @@ console.log(7);
 
 Підведемо підсумки,
 
-1. Числа `1` і `7` з’являються відразу, тому що прості виклики `console.log` не використовують жодних черг.
+1. Числа `1` і `7` з'являються відразу, тому що прості виклики `console.log` не використовують жодних черг.
 2. Потім, після завершення основного потоку коду, запускається черга мікрозадач.
     - Він містить команди: `console.log(3); setTimeout(...4); console.log(5)`.
-    - З’являються числа `3` і `5`, а `setTimeout(() => console.log(4))` додає виклик `console.log(4)` в кінець черги макрозадач.
+    - З'являються числа `3` і `5`, а `setTimeout(() => console.log(4))` додає виклик `console.log(4)` в кінець черги макрозадач.
     - Черга макрозадач тепер така: `console.log(2); console.log(6); console.log(4)`.
 3. Після того як черга мікрозадач стає порожньою, виконується черга макрозадач. І він виводить `2`, `6`, `4`.
 
diff --git a/2-ui/99-ui-misc/03-event-loop/article.md b/2-ui/99-ui-misc/03-event-loop/article.md
index 3b0d686a9..a71eae9bf 100644
--- a/2-ui/99-ui-misc/03-event-loop/article.md
+++ b/2-ui/99-ui-misc/03-event-loop/article.md
@@ -15,7 +15,7 @@
 
 1. Поки є завдання:
     - виконати їх, починаючи з найстарішого.
-2. Очікувати поки завдання не з’явиться, потім перейти до пункту 1.
+2. Очікувати поки завдання не з'явиться, потім перейти до пункту 1.
 
 Це формалізація того, що ми бачимо, гортаючи вебсторінку. Рушій JavaScript більшість часу не робить нічого, він працює лише коли спрацьовує скрипт, обробник подій чи подія.
 
@@ -26,7 +26,7 @@
 - Коли пройде час, запрограмований в `setTimeout`, тоді завдання запустити його колбек.
 - ...і так далі.
 
-З’являються задачі для виконання -- рушій виконує їх -- потім очікує нових завдань (майже не навантажуючи процесор в режимі очікування).
+З'являються задачі для виконання -- рушій виконує їх -- потім очікує нових завдань (майже не навантажуючи процесор в режимі очікування).
 
 Може трапитись так, що завдання приходить тоді, коли рушій вже зайнятий, тоді це завдання стає в чергу.
 
@@ -42,7 +42,7 @@
 
 Ще декілька деталей:
 1. Рендеринг ніколи не відбувається поки рушій виконує завдання. Не має значення наскільки довго виконується завдання. Зміни в DOM будуть відмальовані лише після завершення завдання.
-2. Якщо виконання завдання займає надто багато часу, браузер не зможе виконувати інші завдання, наприклад, обробляти користувацькі події. Тож після недовгого часу "зависання" з’явиться оповіщення "Сторінка не відповідає" і пропозиція вбити процес виконання завдання разом з цілою сторінкою. Таке трапляється коли код містить багато складних обрахунків або виникає програмна помилка, що створює нескінченний цикл.
+2. Якщо виконання завдання займає надто багато часу, браузер не зможе виконувати інші завдання, наприклад, обробляти користувацькі події. Тож після недовгого часу "зависання" з'явиться оповіщення "Сторінка не відповідає" і пропозиція вбити процес виконання завдання разом з цілою сторінкою. Таке трапляється коли код містить багато складних обрахунків або виникає програмна помилка, що створює нескінченний цикл.
 
 Що ж, це була теорія. Тепер побачимо як можна використати ці знання на практиці.
 
@@ -50,9 +50,9 @@
 
 Припустимо у нас є завдання, що потребує значних ресурсів процесора.
 
-Наприклад, підсвічування синтаксису (використовується для виділення кольором коду на цій сторінці) доволі важке завдання для процесора. Щоб розмалювати код, процесор його аналізує, створює багато кольорових елементів, додає їх в документ -- для великих об’ємів тексту це займає багато часу.
+Наприклад, підсвічування синтаксису (використовується для виділення кольором коду на цій сторінці) доволі важке завдання для процесора. Щоб розмалювати код, процесор його аналізує, створює багато кольорових елементів, додає їх в документ -- для великих об'ємів тексту це займає багато часу.
 
-Поки рушій зайнятий підсвічуванням синтаксису він не може виконувати інші речі, пов’язані з DOM, обробляти користувацькі події тощо. Це може спричинити "зависання" браузера, що є неприйнятним.
+Поки рушій зайнятий підсвічуванням синтаксису він не може виконувати інші речі, пов'язані з DOM, обробляти користувацькі події тощо. Це може спричинити "зависання" браузера, що є неприйнятним.
 
 Ми можемо уникнути проблем шляхом розбивання великого завдання на шматочки. Підсвітити перші 100 рядків, потім поставити `setTimeout` (з нульовою затримкою) для наступних 100 рядків і так далі.
 
@@ -80,7 +80,7 @@ count();
 
 Браузер навіть може показати повідомлення "скрипт виконується надто довго".
 
-Давайте розіб’ємо роботу на частини, використавши вкладені виклики `setTimeout`:
+Давайте розіб'ємо роботу на частини, використавши вкладені виклики `setTimeout`:
 
 ```js run
 let i = 0;
@@ -113,7 +113,7 @@ count();
 2. Друге виконання обчислює: `i=1000001..2000000`.
 3. ...і так далі.
 
-Тепер, якщо з’являється нове стороннє завдання (таке як подія `onclick`) поки рушій виконує частину 1, воно стає в чергу і виконується після закінчення частини 1, перед наступною частиною. Періодичні повернення в цикл подій між виконанням `count` дають рушію достатньо "простору", щоб зробити щось іще, відреагувати на дії користувача.
+Тепер, якщо з'являється нове стороннє завдання (таке як подія `onclick`) поки рушій виконує частину 1, воно стає в чергу і виконується після закінчення частини 1, перед наступною частиною. Періодичні повернення в цикл подій між виконанням `count` дають рушію достатньо "простору", щоб зробити щось іще, відреагувати на дії користувача.
 
 Примітна річ, що обидва варіанти -- з розбиттям і без розбиття роботи з `setTimeout` -- майже не відрізняються за швидкістю. Немає великої різниці в загальному часі підрахунку.
 
@@ -269,7 +269,7 @@ alert("code");
 
 Всі мікрозавдання завершуються до обробки будь-яких подій чи рендерингу чи виконання інших макрозавдань.
 
-Це важливо, тому що це гарантує, що середовище застосунку залишається незмінним між мікрозадачами (не змінились координати мишки, не з’явились нові дані через мережу тощо).
+Це важливо, тому що це гарантує, що середовище застосунку залишається незмінним між мікрозадачами (не змінились координати мишки, не з'явились нові дані через мережу тощо).
 
 Якщо ми хочемо виконати функцію асинхронно (після поточного коду), але до відображення змін чи обробки нових подій, ми можемо запланувати її за допомогою `queueMicrotask`.
 
@@ -310,7 +310,7 @@ alert("code");
     - Поки черга мікрозавдань не пуста:
         - Обрати з черги і виконати найстаріше мікрозавдання.
 3. Відмалювати зміни, якщо вони є.
-4. Якщо черга макрозавдань пуста, зачекати поки макрозавдання з’явиться.
+4. Якщо черга макрозавдань пуста, зачекати поки макрозавдання з'явиться.
 5. Перейти до кроку 1.
 
 Щоб додати в чергу нове *макрозавдання*:

From ee012fbfdd450d7032028e98740da207a949a0f1 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:26 +0300
Subject: [PATCH 03/11] =?UTF-8?q?feat(3-frames-and-windows):=20Changed=20a?=
 =?UTF-8?q?ll=20apostrophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../01-popup-windows/article.md               | 14 +++++-----
 .../03-cross-window-communication/article.md  | 28 +++++++++----------
 .../06-clickjacking/article.md                |  4 +--
 3 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/3-frames-and-windows/01-popup-windows/article.md b/3-frames-and-windows/01-popup-windows/article.md
index 3ee2b687f..3afe9c43b 100644
--- a/3-frames-and-windows/01-popup-windows/article.md
+++ b/3-frames-and-windows/01-popup-windows/article.md
@@ -46,7 +46,7 @@ url
 : URL-адреса для завантаження в нове вікно.
 
 name
-: Ім’я нового вікна. Кожне вікно має `window.name`, і тут ми можемо вказати, яке вікно використовувати для спливаючого вікна. Якщо вікно з такою назвою вже є -- в ньому відкривається дана URL-адреса, інакше відкривається нове вікно. 
+: Ім'я нового вікна. Кожне вікно має `window.name`, і тут ми можемо вказати, яке вікно використовувати для спливаючого вікна. Якщо вікно з такою назвою вже є -- в ньому відкривається дана URL-адреса, інакше відкривається нове вікно. 
 
 params
 : Рядок конфігурації для нового вікна. Він містить налаштування, розділені комою. У параметрах не повинно бути пробілів, наприклад: `width=200,height=100`.
@@ -78,7 +78,7 @@ width=0,height=0,left=-1000,top=-1000`;
 open('/', 'test', params);
 ```
 
-Тут більшість "функцій вікна" вимкнено, а вікно розміщено за екраном. Запустіть і подивіться, що насправді станеться. Більшість браузерів "виправляють" дивні речі, як-от нульове значення `width/height` та від’ємні `left/top`. Наприклад, Chrome відкриває таке вікно з повною шириною/висотою, щоб воно займало весь екран.
+Тут більшість "функцій вікна" вимкнено, а вікно розміщено за екраном. Запустіть і подивіться, що насправді станеться. Більшість браузерів "виправляють" дивні речі, як-от нульове значення `width/height` та від'ємні `left/top`. Наприклад, Chrome відкриває таке вікно з повною шириною/висотою, щоб воно займало весь екран.
 
 Давайте додамо звичайні параметри позиціонування та прийнятні координати `width`, `height`, `left`, `top`:
 
@@ -148,7 +148,7 @@ newWin.document.write(
 );
 ```
 
-Таким чином, зв’язок між вікнами є двонаправленим: основне вікно та спливаюче вікно мають посилання один на одного.
+Таким чином, зв'язок між вікнами є двонаправленим: основне вікно та спливаюче вікно мають посилання один на одного.
 
 ## Закриття спливаючого вікна
 
@@ -177,13 +177,13 @@ newWindow.onload = function() {
 Існують методи переміщення/зміни розміру вікна:
 
 `win.moveBy(x,y)`
-: Перемістити вікно відносно поточної позиції `x` пікселів праворуч і `y` пікселів вниз. Допускаються від’ємні значення (переміщення вліво/вгору).
+: Перемістити вікно відносно поточної позиції `x` пікселів праворуч і `y` пікселів вниз. Допускаються від'ємні значення (переміщення вліво/вгору).
 
 `win.moveTo(x,y)`
 : Перемістити вікно до координат `(x,y)` на екрані.
 
 `win.resizeBy(width,height)`
-: Змінити розмір вікна на задану `width/height` відносно поточного розміру. Допускаються від’ємні значення.
+: Змінити розмір вікна на задану `width/height` відносно поточного розміру. Допускаються від'ємні значення.
 
 `win.resizeTo(width,height)`
 : Змінити розмір вікна на заданий.
@@ -205,7 +205,7 @@ JavaScript не має можливості згортати або розгор
 Ми вже говорили про прокручування вікна в розділі <info:size-and-scroll-window>.
 
 `win.scrollBy(x,y)`
-: Прокрутить вікно `x` пікселів праворуч і `y` вниз відносно поточного прокручування. Допускаються від’ємні значення.
+: Прокрутить вікно `x` пікселів праворуч і `y` вниз відносно поточного прокручування. Допускаються від'ємні значення.
 
 `win.scrollTo(x,y)`
 : Прокрутить вікно до заданих координат `(x,y)`.
@@ -247,7 +247,7 @@ window.onblur = () => window.focus();
 Якщо ми збираємося відкрити спливаюче вікно, хороша практика -- повідомити про це користувача. Значок "відкриття вікна" поруч із посиланням або кнопкою дозволить відвідувачеві зрозуміти, що відбувається з фокусом і не втратити обидва вікна з поля зору.
 
 - Спливаюче вікно можна відкрити за допомогою виклику `open(url, name, params)`. Він повертає посилання на щойно відкрите вікно.
-- Браузери блокують виклики `open` з коду за межами дій користувача. Зазвичай з’являється сповіщення, щоб користувач міг їх дозволити.
+- Браузери блокують виклики `open` з коду за межами дій користувача. Зазвичай з'являється сповіщення, щоб користувач міг їх дозволити.
 - Типово браузери відкривають нову вкладку, але якщо вказано розміри, то це буде спливаюче вікно.
 - Спливаюче вікно може отримати доступ до основного вікна за допомогою властивості `window.opener`.
 - Основне вікно та спливаюче вікно можуть вільно читати та змінювати одне одного, якщо вони мають однакове походження. Інакше вони можуть змінити розташування один одного та [обмінюватися повідомленнями](info:cross-window-communication).
diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 8b34ca91f..068f4c5ef 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -28,7 +28,7 @@
 
 ### iframe на практиці
 
-Кожен `<iframe>` містить окреме вбудоване вікно з окремими об’єктами `document` та `window`.
+Кожен `<iframe>` містить окреме вбудоване вікно з окремими об'єктами `document` та `window`.
 
 Ми можемо отримати до них доступ за допомогою властивостей:
 
@@ -59,7 +59,7 @@
 
     // ми також не можемо ПРОЧИТАТИ URL-адресу сторінки в iframe
     try {
-      // Не вдається прочитати URL-адресу з об’єкта Location
+      // Не вдається прочитати URL-адресу з об'єкта Location
 *!*
       let href = iframe.contentWindow.location.href; // ПОМИЛКА
 */!*
@@ -97,7 +97,7 @@
 ```
 
 ```smart header="`iframe.onload` vs `iframe.contentWindow.onload`"
-Подія `iframe.onload` (у тегу `<iframe>`) по суті така ж, як `iframe.contentWindow.onload` (у вбудованому об’єкті вікна). Вона запускається, коли вбудоване вікно повністю завантажується зі всіма ресурсами. 
+Подія `iframe.onload` (у тегу `<iframe>`) по суті така ж, як `iframe.contentWindow.onload` (у вбудованому об'єкті вікна). Вона запускається, коли вбудоване вікно повністю завантажується зі всіма ресурсами. 
 
 ...Але ми не можемо отримати доступ до `iframe.contentWindow.onload` для iframe з іншим походженням, тому використовуємо `iframe.onload`.
 ```
@@ -125,7 +125,7 @@ document.domain = 'site.com';
 
 ## Iframe: підводний камінь при роботі з document
 
-Коли iframe має однакове подходження походження з оригінальним сайтом, і ми можемо отримати доступ до його `document`, з’являється підводний камінь, про який важливо знати.
+Коли iframe має однакове подходження походження з оригінальним сайтом, і ми можемо отримати доступ до його `document`, з'являється підводний камінь, про який важливо знати.
 
 Після створення iframe одразу має document. Але цей document буде іншим після того, як закінчеться завантаження iframe!
 
@@ -177,10 +177,10 @@ document.domain = 'site.com';
 
 ## Колекція: window.frames
 
-Альтернативний спосіб отримати об’єкт вікна для `<iframe>` -- це отримати його з іменованої колекції `window.frames`:
+Альтернативний спосіб отримати об'єкт вікна для `<iframe>` -- це отримати його з іменованої колекції `window.frames`:
 
-- За номером: `window.frames[0]` -- об’єкт вікна для першого фрейму в документі.
-- За назвою: `window.frames.iframeName` -- об’єкт вікна для фрейму з `name="iframeName"`.
+- За номером: `window.frames[0]` -- об'єкт вікна для першого фрейму в документі.
+- За назвою: `window.frames.iframeName` -- об'єкт вікна для фрейму з `name="iframeName"`.
 
 Наприклад:
 
@@ -193,7 +193,7 @@ document.domain = 'site.com';
 </script>
 ```
 
-Усередині iframe можуть бути інші iframe. Відповідні об’єкти `window` утворюють ієрархію.
+Усередині iframe можуть бути інші iframe. Відповідні об'єкти `window` утворюють ієрархію.
 
 Навігаційні посилання:
 
@@ -228,7 +228,7 @@ if (window == top) { // current window == window.top?
 Ось список обмежень:
 
 `allow-same-origin`
-: Типово атрибут `"sandbox"` нав’язує політику "іншого походження" для iframe. Це змушує браузер сприймати `iframe`, як iframe з іншим походженням, навіть якщо його `src` вказує на той самий сайт. Це застосовує усі неявні обмеженнями для скриптів. Цей параметр вимикає цю функцію.
+: Типово атрибут `"sandbox"` нав'язує політику "іншого походження" для iframe. Це змушує браузер сприймати `iframe`, як iframe з іншим походженням, навіть якщо його `src` вказує на той самий сайт. Це застосовує усі неявні обмеженнями для скриптів. Цей параметр вимикає цю функцію.
 
 `allow-top-navigation`
 : Дозволяє `iframe` змінити `parent.location`.
@@ -270,12 +270,12 @@ if (window == top) { // current window == window.top?
 Аргументи:
 
 `data`
-: Дані для відправки. Можуть бути будь-яким об’єктом, дані клонуються за допомогою "алгоритму структурованої серіалізації". IE підтримує лише рядки, тому ми повинні застосувати `JSON.stringify` для складних об’єктів для підтримки цього браузера.
+: Дані для відправки. Можуть бути будь-яким об'єктом, дані клонуються за допомогою "алгоритму структурованої серіалізації". IE підтримує лише рядки, тому ми повинні застосувати `JSON.stringify` для складних об'єктів для підтримки цього браузера.
 
 `targetOrigin`
 : Вказує джерело для цільового вікна, щоб повідомлення отримувало лише вікно з даного джерела.
 
-`targetOrigin` є заходом безпеки. Пам’ятайте, якщо цільове вікно походить з іншого джерела, ми не можемо прочитати його `location` у вікні відправника. Тому ми не можемо бути впевнені, який сайт зараз відкритий у передбачуваному вікні: користувач міг би піти, а вікно відправника не має про це поняття.
+`targetOrigin` є заходом безпеки. Пам'ятайте, якщо цільове вікно походить з іншого джерела, ми не можемо прочитати його `location` у вікні відправника. Тому ми не можемо бути впевнені, який сайт зараз відкритий у передбачуваному вікні: користувач міг би піти, а вікно відправника не має про це поняття.
 
 `targetOrigin` гарантує, що iframe отримає дані, лише якщо він все ще знаходиться на потрібному сайті. Це важливо, коли дані є чутливими або конфіденційними.
 
@@ -310,7 +310,7 @@ if (window == top) { // current window == window.top?
 
 Щоб отримати повідомлення, вікно отримувач має мати обробник події `message`. Він запускається, коли викликається `postMessage` (і перевірка `targetOrigin` успішна).
 
-Об’єкт події має спеціальні властивості:
+Об'єкт події має спеціальні властивості:
 
 `data`
 : Дані від `postMessage`.
@@ -351,7 +351,7 @@ window.addEventListener("message", function(event) {
 - Зі спливаючого вікна: `window.opener` -- це посилання на основне вікно зі спливаючого вікна.
 
 Для iframes ми можемо отримати доступ до батьківських/дочірніх вікон за допомогою:
-- `window.frames` -- набір вкладених об’єктів вікна,
+- `window.frames` -- набір вкладених об'єктів вікна,
 - `window.parent`, `window.top` посилання на батьківське та верхнє вікна,
 - `iframe.contentWindow` -- вікно всередині тегу `<iframe>`.
 
@@ -372,6 +372,6 @@ window.addEventListener("message", function(event) {
 3. Якщо це так, то `targetWin` ініціює подію `message` зі спеціальними властивостями:
     - `origin` -- походження вікна відправника (наприклад, `http://my.site.com`)
     - `source` -- посилання на вікно відправника.
-    - `data` -- дані, можуть бути об’єктом скрізь, крім IE (в IE тільки рядок).
+    - `data` -- дані, можуть бути об'єктом скрізь, крім IE (в IE тільки рядок).
 
     Ми повинні використовувати `addEventListener`, щоб встановити обробник для цієї події всередині вікна отримувача.
diff --git a/3-frames-and-windows/06-clickjacking/article.md b/3-frames-and-windows/06-clickjacking/article.md
index 1822a5f57..e8f3e2032 100644
--- a/3-frames-and-windows/06-clickjacking/article.md
+++ b/3-frames-and-windows/06-clickjacking/article.md
@@ -51,7 +51,7 @@ iframe { /* iframe із сайту жертви */
 
 Тут ми маємо напівпрозорий `<iframe src="facebook.html">`, і в прикладі ми бачимо його над кнопкою. Натискаючи кнопку користувач фактично натискає на iframe, але не бачить його, оскільки iframe прозорий.
 
-Як наслідок, якщо відвідувач авторизований у Facebook (як правило, "запам’ятати мене" включено), він додає "подобається". У Twitter це була б кнопка "Підписатися".
+Як наслідок, якщо відвідувач авторизований у Facebook (як правило, "запам'ятати мене" включено), він додає "подобається". У Twitter це була б кнопка "Підписатися".
 
 Ось той самий приклад, але ближчий до реальності, з `opacity:0` для `<iframe>`:
 
@@ -213,7 +213,7 @@ Clickjacking -- це спосіб "обдурити" користувачів, 
 
 Хакер може розмістити в повідомленні посилання на свою шкідливу сторінку або заманити відвідувачів якимось іншим способом. Існує багато варіацій.
 
-З однієї точки зору -- атака "не глибока": все, що робить хакер, це перехоплює один клік. Але з іншої -- якщо хакер знає, що після натискання з’явиться інший елемент керування, він може використовувати хитрі повідомлення, щоб змусити користувача натиснути на них.
+З однієї точки зору -- атака "не глибока": все, що робить хакер, це перехоплює один клік. Але з іншої -- якщо хакер знає, що після натискання з'явиться інший елемент керування, він може використовувати хитрі повідомлення, щоб змусити користувача натиснути на них.
 
 Атака досить небезпечна, тому що коли ми розробляємо інтерфейс користувача, ми зазвичай не очікуємо, що хакер може клацнути від імені відвідувача. Тому вразливість можна знайти в абсолютно несподіваних місцях.
 

From 0e7c413a1d437099454d54fff2f9045329832002 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:26 +0300
Subject: [PATCH 04/11] =?UTF-8?q?feat(4-binary):=20Changed=20all=20apostro?=
 =?UTF-8?q?phes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../01-arraybuffer-binary-arrays/article.md   | 38 +++++++++----------
 4-binary/02-text-decoder/article.md           | 12 +++---
 4-binary/03-blob/article.md                   | 38 +++++++++----------
 4-binary/04-file/article.md                   | 24 ++++++------
 4 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md
index 3150aefab..b0eb69ac5 100644
--- a/4-binary/01-arraybuffer-binary-arrays/article.md
+++ b/4-binary/01-arraybuffer-binary-arrays/article.md
@@ -9,7 +9,7 @@
 
 Бінарні дані в JavaScript реалізовано не так, як в інших мовах програмування. Але, якщо трошки розібратися, все виявиться досить простим.
 
-**Базовим об’єктом для роботи з бінарними даними є `ArrayBuffer` -- посилання на неперервну область пам’яті фіксованої довжини.**
+**Базовим об'єктом для роботи з бінарними даними є `ArrayBuffer` -- посилання на неперервну область пам'яті фіксованої довжини.**
 
 Масив створюється наступним чином:
 ```js run
@@ -17,20 +17,20 @@ let buffer = new ArrayBuffer(16); // створити буфер з довжин
 alert(buffer.byteLength); // 16
 ```
 
-Це виділяє неперервну область пам’яті з довжиною 16 байт та заповнює нулями.
+Це виділяє неперервну область пам'яті з довжиною 16 байт та заповнює нулями.
 
 ```warn header="`ArrayBuffer` не є масивом"
 Позбудьмося можливого джерела непорозумінь. `ArrayBuffer` не має нічого спільного з `Array`:
 - Він має фіксовану довжину, що не може бути збільшена чи зменшена.
 - Він займає саме стільки місця, скільки виділено при створенні.
-- Для доступу до окремих байтів нам знадобиться окремий об’єкт представлення, `buffer[index]` не спрацює.
+- Для доступу до окремих байтів нам знадобиться окремий об'єкт представлення, `buffer[index]` не спрацює.
 ```
 
-`ArrayBuffer` - область пам’яті. Що там зберігається? Просто послідовність байтів, що можна інтерпретувати як нам потрібно.
+`ArrayBuffer` - область пам'яті. Що там зберігається? Просто послідовність байтів, що можна інтерпретувати як нам потрібно.
 
-**Для роботи з `ArrayBuffer` нам потрібен спеціальний об’єкт "представлення".**
+**Для роботи з `ArrayBuffer` нам потрібен спеціальний об'єкт "представлення".**
 
-Власне об’єкт представлення не зберігає ніяких даних. Це "вікно", що надає певну інтерпретацію "сирих" байтів всередині `ArrayBuffer`.
+Власне об'єкт представлення не зберігає ніяких даних. Це "вікно", що надає певну інтерпретацію "сирих" байтів всередині `ArrayBuffer`.
 
 Наприклад:
 
@@ -43,9 +43,9 @@ alert(buffer.byteLength); // 16
 
 ![](arraybuffer-views.svg)
 
-`ArrayBuffer` - головний об’єкт представлення даних, що є простою послідовністю байтів.
+`ArrayBuffer` - головний об'єкт представлення даних, що є простою послідовністю байтів.
 
-Якщо нам знадобиться щось туди записати, перебрати їх або для будь-якої іншої операції -- нам знадобиться об’єкт представлення:
+Якщо нам знадобиться щось туди записати, перебрати їх або для будь-якої іншої операції -- нам знадобиться об'єкт представлення:
 
 ```js run
 let buffer = new ArrayBuffer(16); // створення буферу з довжиною 16
@@ -71,7 +71,7 @@ for(let num of view) {
 
 ## TypedArray
 
-Спільним терміном для опису об’єктів представлень (`Uint8Array`, `Uint32Array` тощо) є [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Всі вони мають однаковий набір методів та властивостей.
+Спільним терміном для опису об'єктів представлень (`Uint8Array`, `Uint32Array` тощо) є [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Всі вони мають однаковий набір методів та властивостей.
 
 Зверніть увагу, не існує конструктору з іменем `TypedArray`, це просто термін, що використовується для опису представлень `ArrayBuffer`: `Int8Array`, `Uint8Array` і так далі.
 
@@ -91,11 +91,11 @@ new TypedArray(length);
 new TypedArray();
 ```
 
-1. Якщо передається аргумент типу `ArrayBuffer`, то об’єкт представлення створюється для нього. Ми вже використовувати такий синтаксис.
+1. Якщо передається аргумент типу `ArrayBuffer`, то об'єкт представлення створюється для нього. Ми вже використовувати такий синтаксис.
 
-    Необов’язкові аргументи: `byteOffset` вибору зміщення від початку (типове значення 0) та `length` (типове значення відповідає кінцю) - дозволяють працювати з частиною даних з `buffer`.
+    Необов'язкові аргументи: `byteOffset` вибору зміщення від початку (типове значення 0) та `length` (типове значення відповідає кінцю) - дозволяють працювати з частиною даних з `buffer`.
 
-2. Якщо передати `Array` чи будь-який об’єкт схожий на масив - це створить типізований масив такої ж довжини і з копією вмісту.
+2. Якщо передати `Array` чи будь-який об'єкт схожий на масив - це створить типізований масив такої ж довжини і з копією вмісту.
 
     Ми можемо використовувати це для заповнення масиву даними:
     ```js run
@@ -124,13 +124,13 @@ new TypedArray();
 
 5. Без аргументів буде створено типізований масив нульової довжини.
 
-`TypedArray` можна створити безпосередньо, без використання `ArrayBuffer`. Але об’єкт представлення не може існувати без базового `ArrayBuffer`, тому його буде створено автоматично в усіх випадках окрім першого (коли `ArrayBuffer` передано безпосередньо).
+`TypedArray` можна створити безпосередньо, без використання `ArrayBuffer`. Але об'єкт представлення не може існувати без базового `ArrayBuffer`, тому його буде створено автоматично в усіх випадках окрім першого (коли `ArrayBuffer` передано безпосередньо).
 
 Для доступу до внутрішнього `ArrayBuffer` `TypedArray` має властивості:
 - `buffer` -- посилання на `ArrayBuffer`.
 - `byteLength` -- довжина `ArrayBuffer`.
 
-Отже, ми можемо завжди змінити об’єкт представлення на інший:
+Отже, ми можемо завжди змінити об'єкт представлення на інший:
 ```js
 let arr8 = new Uint8Array([0, 1, 2, 3]);
 
@@ -143,7 +143,7 @@ let arr16 = new Uint16Array(arr8.buffer);
 
 - `Uint8Array`, `Uint16Array`, `Uint32Array` -- для цілих беззнакових чисел з довжиною 8, 16 або 32 біт.
   - `Uint8ClampedArray` -- для 8-бітових беззнакових цілих чисел, що "обрізаються" при присвоєнні (пояснення нижче).
-- `Int8Array`, `Int16Array`, `Int32Array` -- для цілих чисел зі знаком (можуть мати від’ємні значення).
+- `Int8Array`, `Int16Array`, `Int32Array` -- для цілих чисел зі знаком (можуть мати від'ємні значення).
 - `Float32Array`, `Float64Array` -- для чисел з плаваючою комою зі знаком довжиною 32 або 64 біти.
 
 ```warn header="Не існує `int8` або подібних типів для значень"
@@ -185,7 +185,7 @@ alert(uint8array[0]); // 0
 alert(uint8array[1]); // 1
 ```
 
-`Uint8ClampedArray` є особливим в цьому сенсі, його поведінка відрізняється. Буде збережено 255 для усіх чисел, що більше ніж 255 та 0 для від’ємних чисел. Така поведінка буде в нагоді при обробці зображень.
+`Uint8ClampedArray` є особливим в цьому сенсі, його поведінка відрізняється. Буде збережено 255 для усіх чисел, що більше ніж 255 та 0 для від'ємних чисел. Така поведінка буде в нагоді при обробці зображень.
 
 ## Методи TypedArray
 
@@ -195,7 +195,7 @@ alert(uint8array[1]); // 1
 
 Але є речі, що ми не можемо зробити:
 
-- Немає методу `splice` -- ми не можемо "видалити" значення. В основі типізованих масивів лежить буфер, що є неперервною областю пам’яті фіксованої довжини, а типізовані масиви є всього-на-всього їх представленням. Ми можемо тільки присвоїти нульове значення.
+- Немає методу `splice` -- ми не можемо "видалити" значення. В основі типізованих масивів лежить буфер, що є неперервною областю пам'яті фіксованої довжини, а типізовані масиви є всього-на-всього їх представленням. Ми можемо тільки присвоїти нульове значення.
 - Немає методу `concat`.
 
 Існує 2 додаткових методи:
@@ -248,14 +248,14 @@ dataView.setUint32(0, 0); // встановити 4-байтове число в
 
 ## Підсумки
 
-`ArrayBuffer` - головний об’єкт, що є посиланням на неперервну область пам’яті фіксованої довжини.
+`ArrayBuffer` - головний об'єкт, що є посиланням на неперервну область пам'яті фіксованої довжини.
 
 Для більшості операцій з `ArrayBuffer` нам потрібне представлення.
 
 - Це може бути `TypedArray`:
     - `Uint8Array`, `Uint16Array`, `Uint32Array` -- для беззнакових цілих чисел довжиною 8, 16 та 32 біти.
     - `Uint8ClampedArray` -- для 8-бітових цілих чисел, при присвоєнні відбувається "обрізання" значень.
-    - `Int8Array`, `Int16Array`, `Int32Array` -- для цілих чисел зі знаком (можуть бути від’ємними).
+    - `Int8Array`, `Int16Array`, `Int32Array` -- для цілих чисел зі знаком (можуть бути від'ємними).
     - `Float32Array`, `Float64Array` -- для чисел з плаваючою комою зі знаком довжиною 32 та 64 біти.
 - Чи `DataView` -- представлення, яке дозволяє вибрати формат даних за допомогою методів як `getUint8(offset)`.
 
diff --git a/4-binary/02-text-decoder/article.md b/4-binary/02-text-decoder/article.md
index f7aacb829..44dba23b7 100644
--- a/4-binary/02-text-decoder/article.md
+++ b/4-binary/02-text-decoder/article.md
@@ -2,7 +2,7 @@
 
 А якщо бінарні дані є просто рядком? Наприклад, ми отримали файл з текстовими даними.
 
-Вбудований об’єкт [TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder) дає змогу записати дані в JavaScript рядок із заданого буферу з потрібним кодуванням.
+Вбудований об'єкт [TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder) дає змогу записати дані в JavaScript рядок із заданого буферу з потрібним кодуванням.
 
 Але для початку його необхідно створити:
 ```js
@@ -10,9 +10,9 @@ let decoder = new TextDecoder([label], [options]);
 ```
 
 - **`label`** -- кодування, типово `utf-8`, але також підтримуються `big5`, `windows-1251` та багато інших кодувань.
-- **`options`** -- необов’язковий об’єкт, який задає додаткові налаштування декодера:
+- **`options`** -- необов'язковий об'єкт, який задає додаткові налаштування декодера:
   - **`fatal`** -- булевий параметр, якщо передано `true` -- буде згенеровано виключення для символів, які не вдасться декодувати, в іншому випадку (типово) вони будуть замінені на символ `\uFFFD`.
-  - **`ignoreBOM`** -- булевий параметр, якщо передано `true` -- буде проігноровано BOM (Byte order mark — необов’язковий маркер порядку байтів), рідко трапляється в нагоді.
+  - **`ignoreBOM`** -- булевий параметр, якщо передано `true` -- буде проігноровано BOM (Byte order mark — необов'язковий маркер порядку байтів), рідко трапляється в нагоді.
 
 ...А потім декодувати:
 
@@ -21,8 +21,8 @@ let str = decoder.decode([input], [options]);
 ```
 
 - **`input`** -- `BufferSource` буфер для декодування.
-- **`options`** -- необов’язковий об’єкт:
-  - **`stream`** -- значення `true`, якщо потрібно декодувати потік (stream), тоді `decoder` буде викликано повторно декілька разів для отримання вхідних даних частинами. В такому випадку символи, що складають з декількох байт можуть бути випадково розділеними між частинами. Ця опція дозволяє `TextDecoder` запам’ятати "незакінчені" символи для декодування разом з наступною частиною.
+- **`options`** -- необов'язковий об'єкт:
+  - **`stream`** -- значення `true`, якщо потрібно декодувати потік (stream), тоді `decoder` буде викликано повторно декілька разів для отримання вхідних даних частинами. В такому випадку символи, що складають з декількох байт можуть бути випадково розділеними між частинами. Ця опція дозволяє `TextDecoder` запам'ятати "незакінчені" символи для декодування разом з наступною частиною.
 
 Наприклад:
 
@@ -64,7 +64,7 @@ let encoder = new TextEncoder();
 
 Підтримується тільки кодування "utf-8".
 
-Об’єкт має два методи:
+Об'єкт має два методи:
 - **`encode(str)`** -- повертає `Uint8Array` створений з рядку.
 - **`encodeInto(str, destination)`** -- `str` буде закодовано та записано в `destination`. Параметр `destination` повинен мати тип `Uint8Array`.
 
diff --git a/4-binary/03-blob/article.md b/4-binary/03-blob/article.md
index 211deb641..4d7a4bc29 100644
--- a/4-binary/03-blob/article.md
+++ b/4-binary/03-blob/article.md
@@ -1,10 +1,10 @@
 # Blob
 
-`ArrayBuffer` разом з об’єктами представлень, як частина JavaScript, описані в ECMA стандарті.
+`ArrayBuffer` разом з об'єктами представлень, як частина JavaScript, описані в ECMA стандарті.
 
-Також в браузерах, специфікацією [File API](https://www.w3.org/TR/FileAPI/), визначено додаткові високорівневі об’єкти для роботи з даними, зокрема `Blob`.
+Також в браузерах, специфікацією [File API](https://www.w3.org/TR/FileAPI/), визначено додаткові високорівневі об'єкти для роботи з даними, зокрема `Blob`.
 
-`Blob` складається з необов’язкового рядку `type` (зазвичай MIME тип) та `blobParts` -- послідовності інших `Blob` об’єктів, рядків та `BufferSource`.
+`Blob` складається з необов'язкового рядку `type` (зазвичай MIME тип) та `blobParts` -- послідовності інших `Blob` об'єктів, рядків та `BufferSource`.
 
 ![](blob.svg)
 
@@ -15,7 +15,7 @@ new Blob(blobParts, options);
 ```
 
 - **`blobParts`** масив, що може містити значення типу `Blob`/`BufferSource`/`String`.
-- **`options`** необов’язковий об’єкт з властивостями:
+- **`options`** необов'язковий об'єкт з властивостями:
   - **`type`** -- рядок, що дозволяє додати тип для `Blob`, переважно використовуються MIME тип, наприклад, `image/png`,
   - **`endings`** -- визначає чи потрібно привести всі символи нового рядку, при створенні `Blob`, у відповідність до формату поточної операційної система (`\r\n` або `\n`). Типове значення `"transparent"` (не вносити змін), але якщо потрібно внести зміни, то необхідно вказати `"native"`.
 
@@ -43,11 +43,11 @@ blob.slice([byteStart], [byteEnd], [contentType]);
 
 - **`byteStart`** -- початковий байт, типове значення 0.
 - **`byteEnd`** -- останній байт (не включно, типово до кінця).
-- **`contentType`** -- визначає `type` нового об’єкту, типове значення буде таким же, як у початкових даних.
+- **`contentType`** -- визначає `type` нового об'єкту, типове значення буде таким же, як у початкових даних.
 
-Аргументи такі ж самі, як у `array.slice`, від’ємні числа теж можна використовувати.
+Аргументи такі ж самі, як у `array.slice`, від'ємні числа теж можна використовувати.
 
-```smart header="`Blob` об’єкти незмінні"
+```smart header="`Blob` об'єкти незмінні"
 Дані в `Blob` не можуть бути зміненими, але ми можемо зробити зріз з їх частини, створити новий `Blob` з них, змішати їх в новий `Blob` і так далі.
 
 Поведінка відповідає рядкам в JavaScript: ми не можемо змінити якийсь символ в рядку, але ми можемо створити новий.
@@ -57,7 +57,7 @@ blob.slice([byteStart], [byteEnd], [contentType]);
 
 Blob можна використати як URL для показу вмісту HTML тегів `<a>`, `<img>` та інших.
 
-`Blob` об’єкти можна легко завантажити/вивантажити, під час запиту в заголовку `Content-Type` буде використано значення поля `type`.
+`Blob` об'єкти можна легко завантажити/вивантажити, під час запиту в заголовку `Content-Type` буде використано значення поля `type`.
 
 Розгляньмо простий приклад. Після кліку на посилання, ви завантажите динамічно згенерований `Blob`, як файл з вмістом `hello world`:
 
@@ -99,15 +99,15 @@ blob:https://javascript.info/1e67e00e-860d-40a5-89ae-6ab0cbee6273
 
 Для кожного URL, що створено за допомогою `URL.createObjectURL`, браузер зберігає відображення URL -> `Blob`. Тому такі URL короткі, але дозволяють отримати доступ до `Blob`.
 
-Згенерований URL, разом з посиланням на нього, існує тільки всередині поточної сторінки, доки вона відкрита. Це дозволяє посилатися на `Blob` в тегах `<img>`, `<a>` або будь-якому об’єкті, що очікує URL.
+Згенерований URL, разом з посиланням на нього, існує тільки всередині поточної сторінки, доки вона відкрита. Це дозволяє посилатися на `Blob` в тегах `<img>`, `<a>` або будь-якому об'єкті, що очікує URL.
 
-Але це спричиняє побічний ефект. Доки існує посилання на `Blob` у відображенні, `Blob` повинен залишатися в пам’яті. Браузер не може вивільнити пам’ять, що зайнята `Blob`.
+Але це спричиняє побічний ефект. Доки існує посилання на `Blob` у відображенні, `Blob` повинен залишатися в пам'яті. Браузер не може вивільнити пам'ять, що зайнята `Blob`.
 
-Відображення автоматично очищується, коли сторінка закривається. Тому, якщо потрібно, щоб застосунок довго був активний -- очищення пам’яті може трапитися нескоро.
+Відображення автоматично очищується, коли сторінка закривається. Тому, якщо потрібно, щоб застосунок довго був активний -- очищення пам'яті може трапитися нескоро.
 
-**Тому після створення URL `Blob` буде залишатися в пам’яті навіть, коли вже не потрібен.**
+**Тому після створення URL `Blob` буде залишатися в пам'яті навіть, коли вже не потрібен.**
 
-`URL.revokeObjectURL(url)` видаляє посилання у внутрішньому відображенні, що дозволяє видалити `Blob` (якщо немає інших посилань на нього) і звільнити пам’ять.
+`URL.revokeObjectURL(url)` видаляє посилання у внутрішньому відображенні, що дозволяє видалити `Blob` (якщо немає інших посилань на нього) і звільнити пам'ять.
 
 В останньому прикладі, ми цілеспрямовано одразу викликаємо `URL.revokeObjectURL(link.href)`, бо очікуємо, що `Blob` буде завантажено один раз.
 
@@ -130,7 +130,7 @@ blob:https://javascript.info/1e67e00e-860d-40a5-89ae-6ab0cbee6273
 Браузер розкодує рядок та покаже зображення: <img src="data:image/png;base64,R0lGODlhDAAMAKIFAF5LAP/zxAAAANyuAP/gaP///wAAAAAAACH5BAEAAAUALAAAAAAMAAwAAAMlWLPcGjDKFYi9lxKBOaGcF35DhWHamZUW0K4mAbiwWtuf0uxFAgA7">
 
 
-Для перетворення `Blob` в base64 ми будемо використовувати вбудований об’єкт `FileReader`. Він може читати дані з `Blob` в різних форматах. В наступному розділі [next chapter](info:file) ми глибше з ним познайомимось.
+Для перетворення `Blob` в base64 ми будемо використовувати вбудований об'єкт `FileReader`. Він може читати дані з `Blob` в різних форматах. В наступному розділі [next chapter](info:file) ми глибше з ним познайомимось.
 
 Демонстрація завантаження `Blob` за допомогою base64:
 
@@ -154,10 +154,10 @@ reader.onload = function() {
 Обидва способи створення URL з `Blob` доступні для використання. Але, переважно, `URL.createObjectURL(blob)` простіше та швидше.
 
 ```compare title-plus="URL.createObjectURL(blob)" title-minus="Blob в data url"
-+ Необхідно видаляти посилання на об’єкт для звільнення пам’яті.
++ Необхідно видаляти посилання на об'єкт для звільнення пам'яті.
 + Безпосередній доступ до `Blob` без проміжного "закодування/розкодування".
-- Немає потреби звільняти посилання на об’єкти.
-- Втрати швидкодії та навантаження на пам’ять у разі кодування великих `Blob` об’єктів.
+- Немає потреби звільняти посилання на об'єкти.
+- Втрати швидкодії та навантаження на пам'ять у разі кодування великих `Blob` об'єктів.
 ```
 
 ## Зображення в Blob
@@ -195,7 +195,7 @@ canvas.toBlob(function(blob) {
   link.href = URL.createObjectURL(blob);
   link.click();
 
-  // видаляємо внутрішнє посилання на Blob, щоб браузер міг звільнити пам’ять
+  // видаляємо внутрішнє посилання на Blob, щоб браузер міг звільнити пам'ять
   URL.revokeObjectURL(link.href);
 }, 'image/png');
 ```
@@ -225,7 +225,7 @@ blob.arrayBuffer().then(buffer => /* process the ArrayBuffer */);
 
 Коли ми читаємо та пишемо в blob дані розміром понад `2 ГБ`, використання `arrayBuffer` стає більш інтенсивним для нас. На цьому етапі ми можемо безпосередньо перетворити blob на потік.
 
-Потік -- це спеціальний об’єкт, який дозволяє читати з нього (або записувати в нього) частина за частиною. Це виходить за рамки цієї статті, але ось приклад, і ви можете прочитати більше на сторінці <https://developer.mozilla.org/en-US/docs/Web/API/Streams_API>. Потоки зручні для даних, які придатні для обробки частинами.
+Потік -- це спеціальний об'єкт, який дозволяє читати з нього (або записувати в нього) частина за частиною. Це виходить за рамки цієї статті, але ось приклад, і ви можете прочитати більше на сторінці <https://developer.mozilla.org/en-US/docs/Web/API/Streams_API>. Потоки зручні для даних, які придатні для обробки частинами.
 
 Метод `stream()` інтерфейсу `Blob` повертає `ReadableStream`, який під час читання повертає дані, що містяться в `Blob`.
 
diff --git a/4-binary/04-file/article.md b/4-binary/04-file/article.md
index 5a9e429b2..5893e2772 100644
--- a/4-binary/04-file/article.md
+++ b/4-binary/04-file/article.md
@@ -1,6 +1,6 @@
 # File та FileReader
 
-Об’єкт [File](https://www.w3.org/TR/FileAPI/#dfn-file) наслідується від `Blob` та надає додаткові можливості для роботи з файловою системою.
+Об'єкт [File](https://www.w3.org/TR/FileAPI/#dfn-file) наслідується від `Blob` та надає додаткові можливості для роботи з файловою системою.
 
 Є два способи створити екземпляр `File`.
 
@@ -12,16 +12,16 @@ new File(fileParts, fileName, [options])
 
 - **`fileParts`** -- масив значень, що можуть мати тип Blob/BufferSource/String.
 - **`fileName`** -- рядок з іменем файлу.
-- **`options`** -- необов’язковий об’єкт з властивостями:
+- **`options`** -- необов'язковий об'єкт з властивостями:
     - **`lastModified`** -- мітка часу (ціле число) останньої зміни.
 
 По-друге, частіше ми отримуємо файл із `<input type="file">`, перетягуванням чи іншим способом. У такому випадку інформацію про файл заповнює ОС.
 
 Оскільки клас `File` наслідує `Blob`, екземпляри `File` мають такі самі властивості і ще додаткові:
-- `name` -- ім’я файлу,
+- `name` -- ім'я файлу,
 - `lastModified` -- мітка часу останньої зміни.
 
-Щоб отримати об’єкт `File` з `<input type="file">` потрібно:
+Щоб отримати об'єкт `File` з `<input type="file">` потрібно:
 
 ```html run
 <input type="file" onchange="showFile(this)">
@@ -30,7 +30,7 @@ new File(fileParts, fileName, [options])
 function showFile(input) {
   let file = input.files[0];
 
-  alert(`Ім’я файлу: ${file.name}`); // наприклад my.png
+  alert(`Ім'я файлу: ${file.name}`); // наприклад my.png
   alert(`Дата останньої зміни: ${file.lastModified}`); // наприклад 1552830408824
 }
 </script>
@@ -42,7 +42,7 @@ function showFile(input) {
 
 ## FileReader
 
-[FileReader](https://www.w3.org/TR/FileAPI/#dfn-filereader) -- об’єкт для зчитування даних з `Blob`, а отже і з `File` також.
+[FileReader](https://www.w3.org/TR/FileAPI/#dfn-filereader) -- об'єкт для зчитування даних з `Blob`, а отже і з `File` також.
 
 Дані передаються за допомогою подій, оскільки зчитування даних з диску потребує часу.
 
@@ -61,7 +61,7 @@ let reader = new FileReader(); // без аргументів
 
 Вибір `read*` методу залежить від формату даних з яким ми хочемо працювати.
 
-- `readAsArrayBuffer` -- використовується для низькорівневих операцій з бінарними даними. Для високорівневих операцій, як отримання зрізів, об’єкт `File` успадковується від `Blob`, тому його можна використовувати безпосередньо без читання файлу.
+- `readAsArrayBuffer` -- використовується для низькорівневих операцій з бінарними даними. Для високорівневих операцій, як отримання зрізів, об'єкт `File` успадковується від `Blob`, тому його можна використовувати безпосередньо без читання файлу.
 - `readAsText` -- використовується для текстових файлів, вміст буде записано в рядок.
 - `readAsDataURL` -- використовується, якщо ми хочемо використати дані як вміст `src` тегу `img` або інших. Можна скористатися іншим способом для цього, що описано в розділі <info:blob>: `URL.createObjectURL(file)`.
 
@@ -105,9 +105,9 @@ function readFile(input) {
 ```
 
 ```smart header="`FileReader` для Blob"
-Як описано в розділі <info:blob>, `FileReader` може зчитати вміст будь-яких бінарних об’єктів, а не тільки файлів.
+Як описано в розділі <info:blob>, `FileReader` може зчитати вміст будь-яких бінарних об'єктів, а не тільки файлів.
 
-Це можна використати для перетворення бінарних Blob об’єктів у інші формати:
+Це можна використати для перетворення бінарних Blob об'єктів у інші формати:
 - `readAsArrayBuffer(blob)` -- в `ArrayBuffer`,
 - `readAsText(blob, [encoding])` -- в рядок (альтернативний спосіб до `TextDecoder`),
 - `readAsDataURL(blob)` -- в формат base64-кодованого url.
@@ -126,13 +126,13 @@ function readFile(input) {
 
 `File` успадковується від `Blob`.
 
-На додачу до методів та властивостей, що доступні в `Blob`, об’єкт `File` має властивості `name`, `lastModified`  та ще можливість читати файли з файлової системи. Переважно об’єкт `File` отримується з користувацького вводу, як `<input>` чи Drag'n'Drop подіями (`ondragend`).
+На додачу до методів та властивостей, що доступні в `Blob`, об'єкт `File` має властивості `name`, `lastModified`  та ще можливість читати файли з файлової системи. Переважно об'єкт `File` отримується з користувацького вводу, як `<input>` чи Drag'n'Drop подіями (`ondragend`).
 
-`FileReader` об’єкт може прочитати з файлу чи blob в одному з трьох форматів:
+`FileReader` об'єкт може прочитати з файлу чи blob в одному з трьох форматів:
 - Рядок (`readAsText`).
 - `ArrayBuffer` (`readAsArrayBuffer`).
 - URL в форматі base-64 (`readAsDataURL`).
 
 У багатьох випадках нам не потрібно читати увесь вміст файлу. Так же як і з blob, ми можемо створити коротке посилання за допомогою `URL.createObjectURL(file)` та присвоїти його тегу `<a>` чи `<img>`. Таким чином файл можна завантажити чи показати як зображення, як частину вмісту canvas тощо.
 
-Також легко відправити `File` мережею, бо мережеве API `XMLHttpRequest` чи `fetch` можуть безпосередньо працювати з об’єктами `File`.
+Також легко відправити `File` мережею, бо мережеве API `XMLHttpRequest` чи `fetch` можуть безпосередньо працювати з об'єктами `File`.

From ebc6a2b5b4d190f81d0f38082037f93ad0ec445f Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:26 +0300
Subject: [PATCH 05/11] =?UTF-8?q?feat(5-network):=20Changed=20all=20apostr?=
 =?UTF-8?q?ophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 5-network/01-fetch/article.md              |  2 +-
 5-network/02-formdata/article.md           | 28 ++++----
 5-network/03-fetch-progress/article.md     | 12 ++--
 5-network/04-fetch-abort/article.md        | 14 ++--
 5-network/05-fetch-crossorigin/article.md  |  8 +--
 5-network/06-fetch-api/article.md          |  2 +-
 5-network/07-url/article.md                | 30 ++++-----
 5-network/08-xmlhttprequest/article.md     | 46 ++++++-------
 5-network/09-resume-upload/article.md      |  6 +-
 5-network/10-long-polling/article.md       | 20 +++---
 5-network/11-websocket/article.md          | 66 +++++++++---------
 5-network/12-server-sent-events/article.md | 78 +++++++++++-----------
 12 files changed, 156 insertions(+), 156 deletions(-)

diff --git a/5-network/01-fetch/article.md b/5-network/01-fetch/article.md
index 5d127763e..52e751bac 100644
--- a/5-network/01-fetch/article.md
+++ b/5-network/01-fetch/article.md
@@ -12,7 +12,7 @@ JavaScript може відправляти мережеві запити на с
 
 ...І все це без перезавантаження сторінки!
 
-Є загальний термін "AJAX" (абревіатура від <b>A</b>synchronous <b>J</b>avaScript <b>A</b>nd <b>X</b>ML) для мережевих запитів від JavaScript коду. Але формат XML використовувати не обов’язково: цей термін застарілий, тому це слово (XML) тут. Можливо, ви вже його десь чули.
+Є загальний термін "AJAX" (абревіатура від <b>A</b>synchronous <b>J</b>avaScript <b>A</b>nd <b>X</b>ML) для мережевих запитів від JavaScript коду. Але формат XML використовувати не обов'язково: цей термін застарілий, тому це слово (XML) тут. Можливо, ви вже його десь чули.
 
 Є кілька способів надіслати мережевий запит і отримати інформацію з сервера.
 
diff --git a/5-network/02-formdata/article.md b/5-network/02-formdata/article.md
index dfc2bd81e..5da5f9dd0 100644
--- a/5-network/02-formdata/article.md
+++ b/5-network/02-formdata/article.md
@@ -3,16 +3,16 @@
 
 У цьому розділі йдеться про відправлення HTML-форм: з файлами та без, з додатковими полями й так далі.
 
-Об’єкти [FormData](https://xhr.spec.whatwg.org/#interface-formdata) допоможуть нам із цим. Як ви, напевно, здогадалися за назвою, це об’єкт, що представляє дані HTML форми.
+Об'єкти [FormData](https://xhr.spec.whatwg.org/#interface-formdata) допоможуть нам із цим. Як ви, напевно, здогадалися за назвою, це об'єкт, що представляє дані HTML форми.
 
 Конструктор:
 ```js
 let formData = new FormData([form]);
 ```
 
-Якщо передати в конструктор елемент HTML-форми `form`, то об’єкт, що створюється, автоматично прочитає з неї поля.
+Якщо передати в конструктор елемент HTML-форми `form`, то об'єкт, що створюється, автоматично прочитає з неї поля.
 
-Його особливість полягає в тому, що методи для роботи з мережею, наприклад, `fetch`, дозволяють вказати об’єкт `FormData` у властивості тіла запиту `body`.
+Його особливість полягає в тому, що методи для роботи з мережею, наприклад, `fetch`, дозволяють вказати об'єкт `FormData` у властивості тіла запиту `body`.
 
 Тобто для сервера це виглядає як звичайне надсилання форми.
 
@@ -49,24 +49,24 @@ let formData = new FormData([form]);
 
 У цьому прикладі серверний код не представлений, він за рамками цієї статті, він приймає POST-запит із даними форми та відповідає повідомленням «Користувач збережений».
 
-## Методи об’єкта FormData
+## Методи об'єкта FormData
 
-За допомогою наведених нижче методів ми можемо змінювати поля в об’єкті `FormData`:
+За допомогою наведених нижче методів ми можемо змінювати поля в об'єкті `FormData`:
 
-- `formData.append(name, value)` - додає до об’єкта поле з іменем `name` і значенням `value`,
-- `formData.append(name, blob, fileName)` - додає поле так, ніби це `<input type="file">`, третій аргумент `fileName` встановлює ім’я файлу (не ім’я поля форми), ніби це ім’я з файлової системи користувача,
+- `formData.append(name, value)` - додає до об'єкта поле з іменем `name` і значенням `value`,
+- `formData.append(name, blob, fileName)` - додає поле так, ніби це `<input type="file">`, третій аргумент `fileName` встановлює ім'я файлу (не ім'я поля форми), ніби це ім'я з файлової системи користувача,
 - `formData.delete(name)` - видаляє поле по заданому `name`,
 - `formData.get(name)` - дістає значення поля по заданому `name`,
 - `formData.has(name)` - перевіряє чи існує поле по заданому `name`, повертає `true`, інакше `false`
 
-Технічно форма може мати багато полів з тим самим ім’ям `name`, тому кілька викликів `append` додадуть кілька полів з однаковими іменами.
+Технічно форма може мати багато полів з тим самим ім'ям `name`, тому кілька викликів `append` додадуть кілька полів з однаковими іменами.
 
 Ще існує метод `set`, його синтаксис такий самий, як у `append`. Різниця в тому, що `.set` видаляє всі наявні поля з ім'ям `name` і тільки потім додає нове. Тобто цей метод гарантує, що існуватиме лише одне поле з ім'ям `name`, у всьому іншому він аналогічний `.append`:
 
 - `formData.set(name, value)`,
 - `formData.set(name, blob, fileName)`.
 
-Поля об’єкта `formData` можна перебирати, використовуючи цикл `for..of`:
+Поля об'єкта `formData` можна перебирати, використовуючи цикл `for..of`:
 
 ```js run
 let formData = new FormData();
@@ -81,7 +81,7 @@ for(let [name, value] of formData) {
 
 ## Надсилання форми з файлом
 
-Об’єкти `FormData` завжди посилаються із заголовком `Content-Type: multipart/form-data`, цей спосіб кодування дозволяє надсилати файли. Таким чином, поля `<input type="file">` теж відправляються, як і при використанні разі звичайної форми.
+Об'єкти `FormData` завжди посилаються із заголовком `Content-Type: multipart/form-data`, цей спосіб кодування дозволяє надсилати файли. Таким чином, поля `<input type="file">` теж відправляються, як і при використанні разі звичайної форми.
 
 Приклад такої форми:
 
@@ -160,15 +160,15 @@ for(let [name, value] of formData) {
 formData.append("image", imageBlob, "image.png");
 ```
 
-Це як би у формі був елемент `<input type="file" name="image">` і користувач прикріпив би файл з ім’ям `"image.png"` (3й аргумент) та даними `imageBlob` (2й аргумент) зі своєї файлової системи.
+Це як би у формі був елемент `<input type="file" name="image">` і користувач прикріпив би файл з ім'ям `"image.png"` (3й аргумент) та даними `imageBlob` (2й аргумент) зі своєї файлової системи.
 
 Сервер прочитає і дані і файл, так само, якби це була звичайна відправка форми.
 
 ## Підсумки
 
-Об’єкти [FormData](https://xhr.spec.whatwg.org/#interface-formdata) використовуються, щоб взяти дані з HTML-форми та відправити їх за допомогою `fetch` або іншого методу для роботи з мережею.
+Об'єкти [FormData](https://xhr.spec.whatwg.org/#interface-formdata) використовуються, щоб взяти дані з HTML-форми та відправити їх за допомогою `fetch` або іншого методу для роботи з мережею.
 
-Ми можемо створити такий об’єкт з даними, передавши в конструктор HTML-форму -- `new FormData(form)`, або ж можна створити об’єкт взагалі без форми і потім додати до нього поля за допомогою методів:
+Ми можемо створити такий об'єкт з даними, передавши в конструктор HTML-форму -- `new FormData(form)`, або ж можна створити об'єкт взагалі без форми і потім додати до нього поля за допомогою методів:
 
 - `formData.append(name, value)`
 - `formData.append(name, blob, fileName)`
@@ -178,7 +178,7 @@ formData.append("image", imageBlob, "image.png");
 Зазначимо дві особливості:
 
 1. Метод `set` видаляє поля з таким самим іменем, а `append` -- ні. У цьому їхня єдина відмінність.
-2. Щоб надіслати файл, потрібно використовувати синтаксис з трьома аргументами, як третій вказується ім’я файлу, яке зазвичай, при `<input type="file">`, береться з файлової системи.
+2. Щоб надіслати файл, потрібно використовувати синтаксис з трьома аргументами, як третій вказується ім'я файлу, яке зазвичай, при `<input type="file">`, береться з файлової системи.
 
 Інші методи:
 
diff --git a/5-network/03-fetch-progress/article.md b/5-network/03-fetch-progress/article.md
index 5c38d7f65..2fae945a3 100644
--- a/5-network/03-fetch-progress/article.md
+++ b/5-network/03-fetch-progress/article.md
@@ -5,7 +5,7 @@
 
 Будь ласка, зверніть увагу: наразі `fetch` не може відстежувати хід *вивантаження*. Для цієї мети використовуйте [XMLHttpRequest](info:xmlhttprequest), ми розглянемо його пізніше.
 
-Щоб відстежувати хід завантаження, ми можемо використовувати властивість `response.body`. Це `ReadableStream` -- спеціальний об’єкт, який надає тіло відповіді фрагментами, в міру надходження. Потоки для зчитування описані в специфікації [Streams API](https://streams.spec.whatwg.org/#rs-class).
+Щоб відстежувати хід завантаження, ми можемо використовувати властивість `response.body`. Це `ReadableStream` -- спеціальний об'єкт, який надає тіло відповіді фрагментами, в міру надходження. Потоки для зчитування описані в специфікації [Streams API](https://streams.spec.whatwg.org/#rs-class).
 
 На відміну від `response.text()`, `response.json()` та інших методів, `response.body` дає повний контроль над процесом зчитування, і ми можемо підрахувати, скільки даних отримано в будь-який момент.
 
@@ -29,7 +29,7 @@ while(true) {
 }
 ```
 
-Результатом виклику `await reader.read()` є об’єкт з двома властивостями:
+Результатом виклику `await reader.read()` є об'єкт з двома властивостями:
 - **`done`** -- `true`, коли зчитування завершено, інакше -- `false`.
 - **`value`** -- типізований масив байтів: `Uint8Array`.
 
@@ -68,7 +68,7 @@ while(true) {
   console.log(`Отримано ${receivedLength} з ${contentLength}`)
 }
 
-// Крок 4: об’єднуємо фрагменти в один Uint8Array
+// Крок 4: об'єднуємо фрагменти в один Uint8Array
 let chunksAll = new Uint8Array(receivedLength); // (4.1)
 let position = 0;
 for(let chunk of chunks) {
@@ -91,11 +91,11 @@ alert(commits[0].author.login);
    Зауважте, що ми не можемо використовувати обидва ці методи для зчитування однієї відповіді: щоб отримати результат, скористайтеся зчитувачем `response.json()` або методом `response.body()`.
 2. Перед зчитуванням ми можемо визначити повну довжину відповіді із заголовка `Content-Length`.
 
-   Він може бути відсутнім для запитів між джерелами (дивись розділ <info:fetch-crossorigin>), і, взагалі-то, технічно сервер не зобов’язаний його встановлювати. Але зазвичай він присутній.
+   Він може бути відсутнім для запитів між джерелами (дивись розділ <info:fetch-crossorigin>), і, взагалі-то, технічно сервер не зобов'язаний його встановлювати. Але зазвичай він присутній.
 3. Викликаємо `await reader.read()`, до закінчення завантаження.
 
    Ми збираємо фрагменти відповідей у масиві `chunks`. Це важливо, оскільки після того, як відповідь буде використана, ми не зможемо "перезчитати" її за допомогою `response.json()` або іншим способом (ви можете спробувати -- буде помилка).
-4. У кінці ми маємо `chunks` -- масив байтових фрагментів `Uint8Array`. Нам потрібно об’єднати їх в єдиний результат. На жаль, немає єдиного методу, який би їх об’єднав, тому для цього є певний код:
+4. У кінці ми маємо `chunks` -- масив байтових фрагментів `Uint8Array`. Нам потрібно об'єднати їх в єдиний результат. На жаль, немає єдиного методу, який би їх об'єднав, тому для цього є певний код:
    1. Ми створюємо `chunksAll = new Uint8Array(receivedLength)` -- однотипний масив із заданою довжиною.
    2. Потім використовуємо метод `.set(chunk, position)`, щоб скопіювати у нього кожен `chunk` один за одним.
 5. Маємо результат у `chunksAll`. Але це байтовий масив, а не рядок.
@@ -111,4 +111,4 @@ alert(commits[0].author.login);
 
 Ще раз зауважте, що це не для процесу *вивантаження* даних на сервер (зараз немає змоги використовувати `fetch`) -- лише для процесу *завантаження* даних з сервера.
 
-Крім того, якщо розмір завантаження невідомий, ми повинні перевірити `receivedLength` у циклі та зупинити його, як тільки воно досягне певної межі. Щоб `chunks` не переповнювали пам’ять.
\ No newline at end of file
+Крім того, якщо розмір завантаження невідомий, ми повинні перевірити `receivedLength` у циклі та зупинити його, як тільки воно досягне певної межі. Щоб `chunks` не переповнювали пам'ять.
\ No newline at end of file
diff --git a/5-network/04-fetch-abort/article.md b/5-network/04-fetch-abort/article.md
index 0264050a0..2694aceca 100644
--- a/5-network/04-fetch-abort/article.md
+++ b/5-network/04-fetch-abort/article.md
@@ -3,11 +3,11 @@
 
 Як ми знаємо, `fetch` повертає проміс. А в JavaScript, як правило, немає концепції "переривання" промісу. Отже, як ми можемо перервати поточний `fetch`? Наприклад, якщо дії користувача на нашому сайті вказують на те, що `fetch` більше не потрібен.
 
-Для таких цілей є спеціальний вбудований об’єкт: `AbortController`. Його можна використовувати для переривання не тільки `fetch`, але й інших асинхронних завдань.
+Для таких цілей є спеціальний вбудований об'єкт: `AbortController`. Його можна використовувати для переривання не тільки `fetch`, але й інших асинхронних завдань.
 
 Його використання дуже просте:
 
-## Об’єкт AbortController
+## Об'єкт AbortController
 
 Створімо контролер:
 
@@ -15,7 +15,7 @@
 let controller = new AbortController();
 ```
 
-Контролер -- це надзвичайно простий об’єкт.
+Контролер -- це надзвичайно простий об'єкт.
 
 - Він має єдиний метод `abort()`,
 - І єдину властивість `signal`, що дозволяє встановлювати на ньому обробники подій.
@@ -35,7 +35,7 @@ let controller = new AbortController();
 let signal = controller.signal;
 
 // Сторона, що виконує операцію, яку можна скасувати
-// отримує об’єкт "signal"
+// отримує об'єкт "signal"
 // і налаштовує прослуховувач на тригер, коли викликається controller.abort()
 signal.addEventListener('abort', () => alert("переривання!"));
 
@@ -48,9 +48,9 @@ alert(signal.aborted); // true
 
 Як ми бачимо, `AbortController` є лише засобом для передачі подій `abort`, коли для нього викликається `abort()`.
 
-Ми могли б реалізувати такий самий тип прослуховування подій у нашому коді самостійно, без об’єкта `AbortController`.
+Ми могли б реалізувати такий самий тип прослуховування подій у нашому коді самостійно, без об'єкта `AbortController`.
 
-Але цінним є те, що `fetch` знає, як працювати з об’єктом `AbortController`. Він інтегрований у нього.
+Але цінним є те, що `fetch` знає, як працювати з об'єктом `AbortController`. Він інтегрований у нього.
 
 ## Використання з fetch
 
@@ -143,6 +143,6 @@ let results = await Promise.all([...fetchJobs, ourJob]);
 
 ## Підсумки
 
-- `AbortController` -- це простий об’єкт, який генерує подію `abort` для своєї властивості `signal` під час виклику методу `abort()` (а також встановлює для `signal.aborted` значення `true`).
+- `AbortController` -- це простий об'єкт, який генерує подію `abort` для своєї властивості `signal` під час виклику методу `abort()` (а також встановлює для `signal.aborted` значення `true`).
 - `fetch` інтегрується з ним: ми передаємо властивість `signal` як параметр, а потім `fetch` прослуховує його, тому можна перервати цей `fetch`.
 - Ми можемо використовувати `AbortController` у нашому коді. Взаємодія "виклик `abort()`" -> "прослуховування події `abort`" проста та універсальна. Ми можемо використовувати його навіть без `fetch`.
diff --git a/5-network/05-fetch-crossorigin/article.md b/5-network/05-fetch-crossorigin/article.md
index 94c995059..a4c6b6a84 100644
--- a/5-network/05-fetch-crossorigin/article.md
+++ b/5-network/05-fetch-crossorigin/article.md
@@ -36,7 +36,7 @@ CORS існує для захисту інтернету від злих хак
 
 ### Використання форм
 
-Одним із способів зв’язку з іншим сервером було відправлення туди `<form>`. Люди відправили його в `<iframe>`, просто щоб залишитися на поточній сторінці, ось так:
+Одним із способів зв'язку з іншим сервером було відправлення туди `<form>`. Люди відправили його в `<iframe>`, просто щоб залишитися на поточній сторінці, ось так:
 
 ```html
 <!-- ціль форми -->
@@ -54,7 +54,7 @@ CORS існує для захисту інтернету від злих хак
 
 Таким чином, можна було зробити запит GET/POST на інший сайт, навіть без мережевих методів, оскільки форми можуть надсилати дані будь-куди. Але оскільки доступ до вмісту `<iframe>` з іншого сайту заборонено, прочитати відповідь було неможливо.
 
-Якщо бути точним, для цього насправді були хитрощі, вони вимагали спеціальних скриптів і в iframe, і на сторінці. Тож зв’язок із iframe був технічно можливим. Зараз немає сенсу вдаватися в подробиці, нехай ці динозаври спочивають з миром.
+Якщо бути точним, для цього насправді були хитрощі, вони вимагали спеціальних скриптів і в iframe, і на сторінці. Тож зв'язок із iframe був технічно можливим. Зараз немає сенсу вдаватися в подробиці, нехай ці динозаври спочивають з миром.
 
 ### Використання скриптів
 
@@ -93,7 +93,7 @@ CORS існує для захисту інтернету від злих хак
 
 Це працює та не порушує безпеку, оскільки обидві сторони погодилися передавати дані таким чином. І, коли обидві сторони погоджуються, це точно не хак. Ще існують сервіси, які надають такий доступ, оскільки він працює навіть для дуже старих браузерів.
 
-Через деякий час мережеві методи з’явилися в браузерному JavaScript.
+Через деякий час мережеві методи з'явилися в браузерному JavaScript.
 
 Спочатку запити на інші джерела були заборонені. Але в результаті довгих обговорень було дозволено їх робити, але для будь-яких нових можливостей вимагався явний дозвіл від сервера, що виражений в спеціальних заголовках.
 
@@ -261,7 +261,7 @@ Access-Control-Request-Headers: Content-Type,API-Key
 - `Access-Control-Allow-Methods: PATCH`
 - `Access-Control-Allow-Headers: Content-Type,API-Key`.
 
-Це дозволяє майбутній зв’язок, інакше виникає помилка.
+Це дозволяє майбутній зв'язок, інакше виникає помилка.
 
 Якщо сервер очікує інших методів і заголовків у майбутньому, є сенс дозволити їх заздалегідь, додавши до списку.
 
diff --git a/5-network/06-fetch-api/article.md b/5-network/06-fetch-api/article.md
index e6a95eca0..d0f25c4c1 100644
--- a/5-network/06-fetch-api/article.md
+++ b/5-network/06-fetch-api/article.md
@@ -171,7 +171,7 @@ fetch('https://another.com/page', {
 
 - **`"follow"`** -- типове значення, слідувати HTTP-переадресаціям,
 - **`"error"`** -- помилка при HTTP-переадресації,
-- **`"manual"`** -- дозволяє обробляти HTTP-переадресації вручну. У разі переадресації ми отримаємо спеціальний об’єкт відповіді з `response.type="opaqueredirect"` та нульовим/порожнім статусом і більшістю інших властивостей.
+- **`"manual"`** -- дозволяє обробляти HTTP-переадресації вручну. У разі переадресації ми отримаємо спеціальний об'єкт відповіді з `response.type="opaqueredirect"` та нульовим/порожнім статусом і більшістю інших властивостей.
 
 ## integrity
 
diff --git a/5-network/07-url/article.md b/5-network/07-url/article.md
index 97f33621b..f3a962013 100644
--- a/5-network/07-url/article.md
+++ b/5-network/07-url/article.md
@@ -1,20 +1,20 @@
 
-# URL об’єкти
+# URL об'єкти
 
 Вбудований клас [URL](https://url.spec.whatwg.org/#api) надає зручний інтерфейс для створення та розбирання URL на частини.
 
-Зазвичай, щоб зробити мережевий запит, достатньо передати лише рядок з адресою, передавати саме екземпляр класу `URL` не має жодної потреби. Тому нас ніхто не зобов’язує використовувати клас `URL`. Але іноді це може стати в нагоді.
+Зазвичай, щоб зробити мережевий запит, достатньо передати лише рядок з адресою, передавати саме екземпляр класу `URL` не має жодної потреби. Тому нас ніхто не зобов'язує використовувати клас `URL`. Але іноді це може стати в нагоді.
 
 ## Створення URL
 
-Синтаксис для створення `URL` об’єктів:
+Синтаксис для створення `URL` об'єктів:
 
 ```js
 new URL(url, [base])
 ```
 
 - **`url`** -- повний URL чи, якщо задано другий параметр, тільки шлях (дивись далі),
-- **`base`** -- необов’язковий параметр з "основою" відносно якої буде побудовано URL, якщо в першому параметрі передано тільки шлях.
+- **`base`** -- необов'язковий параметр з "основою" відносно якої буде побудовано URL, якщо в першому параметрі передано тільки шлях.
 
 Наприклад:
 
@@ -41,7 +41,7 @@ let newUrl = new URL('tester', url);
 alert(newUrl); // https://javascript.info/profile/tester
 ```
 
-Об’єкт `URL` дозволяє негайно отримати доступ до його складових, тому це зручний спосіб для розбору URL адреси:
+Об'єкт `URL` дозволяє негайно отримати доступ до його складових, тому це зручний спосіб для розбору URL адреси:
 
 ```js run
 let url = new URL('https://javascript.info/url');
@@ -51,7 +51,7 @@ alert(url.host);     // javascript.info
 alert(url.pathname); // /url
 ```
 
-Підказка зі складовими URL об’єкту:
+Підказка зі складовими URL об'єкту:
 
 ![](url-object.svg)
 
@@ -62,10 +62,10 @@ alert(url.pathname); // /url
 - також можуть бути присутні властивості `user` та `password`, якщо використовується формат для HTTP аутентифікації: `http://login:password@site.com` (не згадано вище, бо рідко використовується).
 
 
-```smart header="`URL` об’єкт можна передати у методи, що використовуються для мережевих запитів замість рядку"
-`fetch` чи `XMLHttpRequest` можуть використовувати `URL` об’єкти майже всюди, де можна передати рядок з `URL`.
+```smart header="`URL` об'єкт можна передати у методи, що використовуються для мережевих запитів замість рядку"
+`fetch` чи `XMLHttpRequest` можуть використовувати `URL` об'єкти майже всюди, де можна передати рядок з `URL`.
 
-Зазвичай, `URL` об’єкт можна передати в будь-який метод замість рядку, оскільки більшість методів перетворять об’єкт в рядок, що містить повну URL-адресу.
+Зазвичай, `URL` об'єкт можна передати в будь-який метод замість рядку, оскільки більшість методів перетворять об'єкт в рядок, що містить повну URL-адресу.
 ```
 
 ## Параметри пошуку "?..."
@@ -80,7 +80,7 @@ new URL('https://google.com/search?query=JavaScript')
 
 ...Але параметри повинні бути закодованими, якщо вони містять пробіли, не латинські символи тощо (більше про це нижче).
 
-Отже, для цього `URL` має властивість: `url.searchParams`, об’єкт типу [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams).
+Отже, для цього `URL` має властивість: `url.searchParams`, об'єкт типу [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams).
 
 Він надає зручні методи для роботи з параметрами пошуку:
 
@@ -91,7 +91,7 @@ new URL('https://google.com/search?query=JavaScript')
 - **`has(name)`** -- перевірити чи існує параметр з іменем `name`,
 - **`set(name, value)`** -- встановити/замінити параметр з іменем `name`,
 - **`sort()`** -- відсортувати параметри за іменем, рідко стає в нагоді,
-- ...і це об’єкт також можна перебрати, подібно до `Map`.
+- ...і це об'єкт також можна перебрати, подібно до `Map`.
 
 Приклад з параметрами, що містять пробіли та знаки пунктуації:
 
@@ -120,7 +120,7 @@ for(let [name, value] of url.searchParams) {
 
 Усі інші символи, що не дозволені стандартом, повинні бути закодовані. Наприклад, не латинські букви та пробіли мають бути замінені на їх UTF-8 коди, що починаються з `%`. Пробіл буде закодовано у вигляді `%20` (з історичних причин пробіл дозволено закодувати як `+`).
 
-Гарна новина полягає в тому, що `URL` об’єкт виконає всі перетворення автоматично. Нам потрібно тільки передати всі параметри, а потім перетворити `URL` в рядок:
+Гарна новина полягає в тому, що `URL` об'єкт виконає всі перетворення автоматично. Нам потрібно тільки передати всі параметри, а потім перетворити `URL` в рядок:
 
 ```js run
 // для прикладу використано кириличні символи
@@ -137,9 +137,9 @@ URL-адреса стала довшою, бо кожен кириличний 
 
 ### Кодування рядків
 
-До появи `URL` об’єктів, розробники використовували рядки для URL-адрес.
+До появи `URL` об'єктів, розробники використовували рядки для URL-адрес.
 
-Наразі, зручніше використовувати `URL` об’єкти, але рядки все ще можна використовувати. У більшості випадків, використання рядків потребує менше коду.
+Наразі, зручніше використовувати `URL` об'єкти, але рядки все ще можна використовувати. У більшості випадків, використання рядків потребує менше коду.
 
 Слід зауважити, якщо ми використовуємо рядки, то закодувати та декодувати символи нам потрібно вручну.
 
@@ -196,7 +196,7 @@ alert(url); // https://google.com/search?q=Rock&Roll
 
 Але нам потрібно закодувати `&` всередині параметрів пошуку, інакше ми отримаємо `q=Rock&Roll`, що означатиме `q=Rock` та незрозумілий параметр `Roll`. Не те, що ми очікували.
 
-Нам слід використовувати тільки `encodeURIComponent` з параметрами пошуку для правильного вставлення в рядок URL. Для повної безпеки, слід кодувати ім’я та значення параметрів, якщо ми не можемо бути повністю впевненими, що вони містять тільки дозволені символи.
+Нам слід використовувати тільки `encodeURIComponent` з параметрами пошуку для правильного вставлення в рядок URL. Для повної безпеки, слід кодувати ім'я та значення параметрів, якщо ми не можемо бути повністю впевненими, що вони містять тільки дозволені символи.
 
 ````smart header="Різниця в кодуванні у порівнянні з `URL`"
 Класи [URL](https://url.spec.whatwg.org/#url-class) та [URLSearchParams](https://url.spec.whatwg.org/#interface-urlsearchparams) ґрунтуються на останній специфікації URL: [RFC3986](https://tools.ietf.org/html/rfc3986), але функції `encode*` використовують застарілу версію [RFC2396](https://www.ietf.org/rfc/rfc2396.txt).
diff --git a/5-network/08-xmlhttprequest/article.md b/5-network/08-xmlhttprequest/article.md
index f55127dcd..e66ec61e5 100644
--- a/5-network/08-xmlhttprequest/article.md
+++ b/5-network/08-xmlhttprequest/article.md
@@ -1,6 +1,6 @@
 # XMLHttpRequest
 
-`XMLHttpRequest` -- це вбудований об’єкт браузера, який дозволяє виконувати HTTP-запити за допомогою JavaScript.
+`XMLHttpRequest` -- це вбудований об'єкт браузера, який дозволяє виконувати HTTP-запити за допомогою JavaScript.
 
 Попри те, що в назві є слово "XML", він може працювати з будь-якими даними, а не лише у форматі XML. Ми можемо завантажувати з/на сервер файли, відстежувати прогрес та багато іншого.
 
@@ -36,11 +36,11 @@ XMLHttpRequest має два режими роботи: синхронний і
     Цей метод приймає основні параметри запиту:
 
     - `method` -- HTTP-метод. Зазвичай `"GET"` або `"POST"`.
-    - `URL` -- URL для запиту, зазвичай це рядок, але може бути і об’єктом [URL](info:url).
+    - `URL` -- URL для запиту, зазвичай це рядок, але може бути і об'єктом [URL](info:url).
     - `async` -- якщо явно встановлено значення `false`, тоді запит буде синхронним, ми розглянемо це трохи пізніше.
     - `user`, `password` -- логін та пароль для базової HTTP аутентифікації (якщо потрібно).
 
-    Зверніть увагу, що виклик метода `open`, всупереч його назві, не відкриває з’єднання. Він лише налаштовує запит, але мережева активність починається лише після виклику метода `send`.
+    Зверніть увагу, що виклик метода `open`, всупереч його назві, не відкриває з'єднання. Він лише налаштовує запит, але мережева активність починається лише після виклику метода `send`.
 
 3. Надіслати запит.
 
@@ -48,7 +48,7 @@ XMLHttpRequest має два режими роботи: синхронний і
     xhr.send([body])
     ```
 
-    Цей метод відкриває з’єднання та надсилає запит на сервер. Необов’язковий параметр `body` містить тіло запиту.
+    Цей метод відкриває з'єднання та надсилає запит на сервер. Необов'язковий параметр `body` містить тіло запиту.
 
     Деякі HTTP-методи запиту, такі як `GET`, не мають тіла. А деякі з них, наприклад `POST`, використовують `body` для завантаження даних на сервер. Ми побачимо приклади цього пізніше.
 
@@ -79,7 +79,7 @@ XMLHttpRequest має два режими роботи: синхронний і
 Ось повний приклад. Наведений нижче код завантажує `/article/xmlhttprequest/example/load` із сервера та показує хід завантаження:
 
 ```js run
-// 1. Створюємо новий об’єкт XMLHttpRequest
+// 1. Створюємо новий об'єкт XMLHttpRequest
 let xhr = new XMLHttpRequest();
 
 // 2. Налаштовуємо його: GET-запит для URL-адреси /article/.../load
@@ -114,7 +114,7 @@ xhr.onerror = function() {
 Після відповіді сервера, ми можемо отримати результат у таких властивостях `xhr`:
 
 `status`
-: Код HTTP статусу (число): `200`, `404`, `403` і так далі, може бути `0` у разі помилки не пов’язаної з HTTP.
+: Код HTTP статусу (число): `200`, `404`, `403` і так далі, може бути `0` у разі помилки не пов'язаної з HTTP.
 
 `statusText`
 : Статусне повідомлення HTTP (рядок): зазвичай `OK` для `200`, `Not Found` для `404`, `Forbidden` для `403` тощо.
@@ -131,7 +131,7 @@ xhr.timeout = 10000; // час очікування в мс, 10 секунд
 Якщо запит не завершився протягом заданого часу, він скасовується і спрацьовує подія `timeout`.
 
 ````smart header="URL-адреса з параметрами"
-Щоб додати параметри до URL-адреси, наприклад `?name=value`, і забезпечити належне кодування, ми можемо використовувати об’єкт [URL](info:url):
+Щоб додати параметри до URL-адреси, наприклад `?name=value`, і забезпечити належне кодування, ми можемо використовувати об'єкт [URL](info:url):
 
 ```js
 let url = new URL('https://google.com/search');
@@ -194,7 +194,7 @@ LOADING = 3; // завантажується відповідь (отриман
 DONE = 4; // запит завершено
 ```
 
-Стани об’єкту `XMLHttpRequest` змінюються у порядку `0` -> `1` -> `2` -> `3` -> ... -> `3` -> `4`. Стан `3` повторюється щоразу, коли отримується пакет даних.
+Стани об'єкту `XMLHttpRequest` змінюються у порядку `0` -> `1` -> `2` -> `3` -> ... -> `3` -> `4`. Стан `3` повторюється щоразу, коли отримується пакет даних.
 
 Ми можемо відстежувати їх за допомогою події `readystatechange`:
 
@@ -259,7 +259,7 @@ try {
 Існує 3 методи для роботи з HTTP-заголовками:
 
 `setRequestHeader(name, value)`
-: Встановлює заголовок запиту із заданими ім’ям `name` та значенням `value`.
+: Встановлює заголовок запиту із заданими ім'ям `name` та значенням `value`.
 
     Наприклад:
 
@@ -291,7 +291,7 @@ try {
     ````
 
 `getResponseHeader(name)`
-: Отримує заголовок відповіді за заданим ім’ям `name` (крім `Set-Cookie` і `Set-Cookie2`).
+: Отримує заголовок відповіді за заданим ім'ям `name` (крім `Set-Cookie` і `Set-Cookie2`).
 
     Наприклад:
 
@@ -311,9 +311,9 @@ try {
     Date: Sat, 08 Sep 2012 16:53:16 GMT
     ```
 
-    Між заголовками завжди є розрив рядка `"\r\n"` (не залежить від ОС), тому ми можемо легко розділити його на окремі заголовки. Роздільником між ім’ям і значенням заголовка завжди є двокрапка з пробілом `": "`. Це зафіксовано в специфікації.
+    Між заголовками завжди є розрив рядка `"\r\n"` (не залежить від ОС), тому ми можемо легко розділити його на окремі заголовки. Роздільником між ім'ям і значенням заголовка завжди є двокрапка з пробілом `": "`. Це зафіксовано в специфікації.
 
-    Отже, якщо ми хочемо отримати об’єкт з парами ім’я/значення, нам потрібно додати трохи JS.
+    Отже, якщо ми хочемо отримати об'єкт з парами ім'я/значення, нам потрібно додати трохи JS.
 
     Ось так (припускаючи, що якщо два заголовки мають однакову назву, то останній замінює попередній):
 
@@ -332,16 +332,16 @@ try {
 
 ## POST, FormData
 
-Щоб зробити запит POST, ми можемо використати вбудований об’єкт [FormData](mdn:api/FormData).
+Щоб зробити запит POST, ми можемо використати вбудований об'єкт [FormData](mdn:api/FormData).
 
 Синтаксис:
 
 ```js
-let formData = new FormData([form]); // створюємо об’єкт, він може бути заповнений з елемента <form>
+let formData = new FormData([form]); // створюємо об'єкт, він може бути заповнений з елемента <form>
 formData.append(name, value); // додаємо поле
 ```
 
-Ми створюємо об’єкт, за бажанням додаємо дані з форми, та якщо потрібно, додаємо поля за допомогою метода `append`, а потім:
+Ми створюємо об'єкт, за бажанням додаємо дані з форми, та якщо потрібно, додаємо поля за допомогою метода `append`, а потім:
 
 1. `xhr.open('POST', ...)` – встановлюємо метод `POST`.
 2. `xhr.send(formData)` – та надсилаємо форму на сервер.
@@ -390,7 +390,7 @@ xhr.setRequestHeader('Content-type', 'application/json; charset=utf-8');
 xhr.send(json);
 ```
 
-Метод `.send(body)` досить всеїдний. Він може надсилати майже будь-які дані у `body`, включаючи об’єкти `Blob` та `BufferSource`.
+Метод `.send(body)` досить всеїдний. Він може надсилати майже будь-які дані у `body`, включаючи об'єкти `Blob` та `BufferSource`.
 
 ## Хід завантаження
 
@@ -400,14 +400,14 @@ xhr.send(json);
 
 Якщо ми завантажуємо на сервер щось велике, то ми, звичайно, більше зацікавлені у відстеженні прогресу завантаження на сервер. Але `xhr.onprogress` тут нам не допоможе.
 
-Існує ще один об’єкт без методів, призначений виключно для відстеження подій завантаження на сервер: `xhr.upload`.
+Існує ще один об'єкт без методів, призначений виключно для відстеження подій завантаження на сервер: `xhr.upload`.
 
 Він генерує події, подібні до `xhr`, але `xhr.upload` ініціює їх виключно під час завантаження на сервер:
 
 - `loadstart` -- розпочато завантаження на сервер.
 - `progress` -- спрацьовує періодично під час завантаження.
 - `abort` -- завантаження перервано.
-- `error` -- помилка не пов’язана з HTTP.
+- `error` -- помилка не пов'язана з HTTP.
 - `load` -- завантаження успішно завершено.
 - `timeout` -- час очікування завантаження минув (якщо встановлено властивість `timeout`).
 - `loadend` -- завантаження завершено (успішно або з помилкою).
@@ -505,7 +505,7 @@ xhr.onprogress = function(event) {
 };
 
 xhr.onerror = function() {
-  // обробляємо помилку не пов’язану з HTTP (наприклад, якщо мережа не працює)
+  // обробляємо помилку не пов'язану з HTTP (наприклад, якщо мережа не працює)
 };
 ```
 
@@ -514,15 +514,15 @@ xhr.onerror = function() {
 - `loadstart` -- запит почався.
 - `progress` -- надійшов пакет даних відповіді, все тіло відповіді на даний момент знаходиться у властивості `response`.
 - `abort` -- запит було скасовано викликом `xhr.abort()`.
-- `error` -- сталася помилка підключення, наприклад неправильне доменне ім’я. Не спрацьовує для HTTP-помилок, таких як 404.
+- `error` -- сталася помилка підключення, наприклад неправильне доменне ім'я. Не спрацьовує для HTTP-помилок, таких як 404.
 - `load` -- запит успішно завершено.
 - `timeout` -- запит було скасовано через тайм-аут (тільки якщо він був встановлений).
 - `loadend` -- спрацьовує після подій `load`, `error`, `timeout` або `abort`.
 
 Події `error`, `abort`, `timeout`, та `load` є взаємовиключними. Може спрацювати лише одна з них.
 
-Найчастіше використовувані події -- це завершення завантаження (`load`), помилка завантаження (`error`), або ми можемо використовувати один обробник `loadend` і перевірити властивості об’єкта запиту `xhr`, щоб побачити, що сталося.
+Найчастіше використовувані події -- це завершення завантаження (`load`), помилка завантаження (`error`), або ми можемо використовувати один обробник `loadend` і перевірити властивості об'єкта запиту `xhr`, щоб побачити, що сталося.
 
-Також ми розглянули іншу подію: `readystatechange`. Вона з’явилася дуже давно, ще до того, як було завершено специфікацію. Нині нема потреби її використовувати, адже є новіші події, але її часто можна зустріти в старих скриптах.
+Також ми розглянули іншу подію: `readystatechange`. Вона з'явилася дуже давно, ще до того, як було завершено специфікацію. Нині нема потреби її використовувати, адже є новіші події, але її часто можна зустріти в старих скриптах.
 
-Якщо ж нам потрібно відстежувати прогрес завантаження на сервер, тоді можна прослуховувати ті самі події на об’єкті `xhr.upload`.
+Якщо ж нам потрібно відстежувати прогрес завантаження на сервер, тоді можна прослуховувати ті самі події на об'єкті `xhr.upload`.
diff --git a/5-network/09-resume-upload/article.md b/5-network/09-resume-upload/article.md
index 8ab4f4875..d0e236895 100644
--- a/5-network/09-resume-upload/article.md
+++ b/5-network/09-resume-upload/article.md
@@ -2,13 +2,13 @@
 
 За допомогою методу `fetch` досить легко завантажити файл.
 
-Але як відновити завантаження після втрати з’єднання? Для цього немає вбудованого функціонала, але у нас є все необхідне для його реалізації.
+Але як відновити завантаження після втрати з'єднання? Для цього немає вбудованого функціонала, але у нас є все необхідне для його реалізації.
 
 Відновлювані завантаження файлів повинні мати індикацію прогресу, оскільки ми очікуємо завантаження великих файлів. Отже, оскільки `fetch` не дозволяє відстежувати хід завантаження на сервер, ми будемо використовувати [XMLHttpRequest](info:xmlhttprequest).
 
 ## Не дуже корисна подія progress
 
-Щоб відновити завантаження, нам потрібно знати, скільки даних було завантажено до втрати з’єднання.
+Щоб відновити завантаження, нам потрібно знати, скільки даних було завантажено до втрати з'єднання.
 
 Існує подія `xhr.upload.onprogress`, яка використовується для відстежування ходу завантаження на сервер.
 
@@ -46,7 +46,7 @@
 
     Якщо файл ще не існує на сервері, тоді відповідь сервера має бути `0`
 
-3. Після цього ми можемо використати метод `slice` об’єкта `Blob`, щоб надіслати файл починаючи з байта вказаного в `startByte`:
+3. Після цього ми можемо використати метод `slice` об'єкта `Blob`, щоб надіслати файл починаючи з байта вказаного в `startByte`:
     ```js
     xhr.open("POST", "upload");
 
diff --git a/5-network/10-long-polling/article.md b/5-network/10-long-polling/article.md
index 3a74ac6ec..b5f19b6f6 100644
--- a/5-network/10-long-polling/article.md
+++ b/5-network/10-long-polling/article.md
@@ -1,6 +1,6 @@
 # Тривале опитування
 
-Тривале опитування (Long polling) -- це найпростіший спосіб реалізувати постійне з’єднання із сервером, без використання спеціального протоколу, такого як WebSocket або Server Side Events.
+Тривале опитування (Long polling) -- це найпростіший спосіб реалізувати постійне з'єднання із сервером, без використання спеціального протоколу, такого як WebSocket або Server Side Events.
 
 Будучи дуже простим у реалізації, він також достатньо хороший у багатьох випадках.
 
@@ -25,15 +25,15 @@
 Як це працює:
 
 1. На сервер надсилається запит.
-2. Сервер не закриває з’єднання, поки не з’явиться повідомлення для відправки.
-3. Коли з’являється повідомлення -- сервер відповідає ним на запит.
+2. Сервер не закриває з'єднання, поки не з'явиться повідомлення для відправки.
+3. Коли з'являється повідомлення -- сервер відповідає ним на запит.
 4. Браузер негайно робить новий запит.
 
-Ситуація, коли браузер відправив запит і має відкрите з’єднання з сервером, є стандартною для цього методу. Лише після доставки повідомлення з’єднання із сервером закривається та відкривається нове.
+Ситуація, коли браузер відправив запит і має відкрите з'єднання з сервером, є стандартною для цього методу. Лише після доставки повідомлення з'єднання із сервером закривається та відкривається нове.
 
 ![](long-polling.svg)
 
-Якщо з’єднання втрачено, скажімо, через помилку мережі, браузер негайно надсилає новий запит.
+Якщо з'єднання втрачено, скажімо, через помилку мережі, браузер негайно надсилає новий запит.
 
 Ось ескіз функції `subscribe` на стороні клієнта, яка виконує тривале опитування:
 
@@ -43,7 +43,7 @@ async function subscribe() {
 
   if (response.status == 502) {
     // Статус 502 -- це помилка тайм-ауту підключення,
-    // вона може статися, коли з’єднання було відкрито занадто довго,
+    // вона може статися, коли з'єднання було відкрито занадто довго,
     // і віддалений сервер або проксі-сервер закрили його.
     // У цьому випадку повторюємо підключення
     await subscribe();
@@ -67,16 +67,16 @@ subscribe();
 
 Як бачите, функція `subscribe` виконує запит, потім чекає на відповідь, обробляє її та знову викликає сама себе.
 
-```warn header="Сервер має підтримувати багато відкритих з’єднань"
-Архітектура сервера повинна вміти працювати з великою кількістю незавершених з’єднаннь.
+```warn header="Сервер має підтримувати багато відкритих з'єднань"
+Архітектура сервера повинна вміти працювати з великою кількістю незавершених з'єднаннь.
 
-Деякі архітектури серверів запускають один процес на одне з’єднання, в результаті чого процесів стає стільки, скільки є з’єднань, при цьому кожен процес споживає досить багато пам’яті. Таким чином, занадто багато з’єднань просто використають усю память.
+Деякі архітектури серверів запускають один процес на одне з'єднання, в результаті чого процесів стає стільки, скільки є з'єднань, при цьому кожен процес споживає досить багато пам'яті. Таким чином, занадто багато з'єднань просто використають усю память.
 
 Це досить часто трапляється з серверами, які використовують мови PHP і Ruby.
 
 Сервери, написані за допомогою Node.js, зазвичай не мають таких проблем.
 
-Тим не менш, це не проблема мови програмування. Більшість сучасних мов, включаючи PHP і Ruby, дозволяють реалізувати належну роботу сервера. Просто переконайтеся, що архітектура вашого сервера добре працює з багатьма одночасними з’єднаннями.
+Тим не менш, це не проблема мови програмування. Більшість сучасних мов, включаючи PHP і Ruby, дозволяють реалізувати належну роботу сервера. Просто переконайтеся, що архітектура вашого сервера добре працює з багатьма одночасними з'єднаннями.
 ```
 
 ## Демо: чат
diff --git a/5-network/11-websocket/article.md b/5-network/11-websocket/article.md
index 5be0d30eb..a2ee7ddb8 100644
--- a/5-network/11-websocket/article.md
+++ b/5-network/11-websocket/article.md
@@ -1,12 +1,12 @@
 # WebSocket
 
-`WebSocket` -- це протокол, описаний у специфікації [RFC 6455](https://datatracker.ietf.org/doc/html/rfc6455), і забезпечує спосіб обміну даними між браузером і сервером через постійне з’єднання. Дані можна передавати в обох напрямках у вигляді "пакетів", без розриву з’єднання та додаткових HTTP-запитів.
+`WebSocket` -- це протокол, описаний у специфікації [RFC 6455](https://datatracker.ietf.org/doc/html/rfc6455), і забезпечує спосіб обміну даними між браузером і сервером через постійне з'єднання. Дані можна передавати в обох напрямках у вигляді "пакетів", без розриву з'єднання та додаткових HTTP-запитів.
 
 WebSocket відмінно підходить для сервісів, що потребують безперервного обміну даними, наприклад онлайн-ігри, системи торгівлі в реальному часі тощо.
 
 ## Простий приклад
 
-Щоб відкрити з’єднання websocket, нам потрібно створити об’єкт `new WebSocket` використовуючи спеціальний протокол `ws` в URL-адресі:
+Щоб відкрити з'єднання websocket, нам потрібно створити об'єкт `new WebSocket` використовуючи спеціальний протокол `ws` в URL-адресі:
 
 ```js
 let socket = new WebSocket("*!*ws*/!*://javascript.info");
@@ -17,16 +17,16 @@ let socket = new WebSocket("*!*ws*/!*://javascript.info");
 ```smart header="Завжди віддавайте перевагу `wss://`"
 Протокол `wss://` не тільки зашифрований, але й більш надійний.
 
-Це тому, що дані `ws://` не зашифровані та видимі для будь-якого посередника. Старі проксі-сервери не знають про WebSocket, тож вони можуть побачити "дивні" заголовки та перервати з’єднання.
+Це тому, що дані `ws://` не зашифровані та видимі для будь-якого посередника. Старі проксі-сервери не знають про WebSocket, тож вони можуть побачити "дивні" заголовки та перервати з'єднання.
 
 З іншого боку, `wss://` -- це WebSocket що використовує TLS (так само, як HTTPS -- це HTTP що використовує TLS), тобто рівень безпеки транспорту шифрує дані у відправника та розшифровує в одержувача. Таким чином, пакети даних передаються зашифрованими, проксі не можуть побачити, що всередині, і пропускають їх.
 ```
 
 Після того, як сокет створено, ми повинні прослуховувати його події. Всьго їх 4:
-- **`open`** -- з’єднання встановлено,
+- **`open`** -- з'єднання встановлено,
 - **`message`** -- отримані дані,
 - **`error`** -- помилка websocket,
-- **`close`** -- з’єднання закрите.
+- **`close`** -- з'єднання закрите.
 
 ...І якщо ми хочемо щось надіслати, то виклик `socket.send(data)` зробить це.
 
@@ -36,7 +36,7 @@ let socket = new WebSocket("*!*ws*/!*://javascript.info");
 let socket = new WebSocket("wss://javascript.info/article/websocket/demo/hello");
 
 socket.onopen = function(e) {
-  alert("[open] З’єднання встановлено");
+  alert("[open] З'єднання встановлено");
   alert("Відправка на сервер");
   socket.send("Мене звати Джон");
 };
@@ -47,11 +47,11 @@ socket.onmessage = function(event) {
 
 socket.onclose = function(event) {
   if (event.wasClean) {  
-    alert(`[close] З’єднання закрите чисто, код=${event.code} причина=${event.reason}`);
+    alert(`[close] З'єднання закрите чисто, код=${event.code} причина=${event.reason}`);
   } else {
     // наприклад сервер завершив процес або мережа не працює
     // у цьому випадку event.code зазвичай дорівнює 1006
-    alert('[close] З’єднання перервано');
+    alert('[close] З'єднання перервано');
   }
 };
 
@@ -60,7 +60,7 @@ socket.onerror = function(error) {
 };
 ```
 
-Для демонстраційних цілей є невеликий сервер [server.js](demo/server.js), написаний на Node.js, для прикладу вище. Він відповідає "Привіт із сервера, Джон", потім чекає 5 секунд і закриває з’єднання.
+Для демонстраційних цілей є невеликий сервер [server.js](demo/server.js), написаний на Node.js, для прикладу вище. Він відповідає "Привіт із сервера, Джон", потім чекає 5 секунд і закриває з'єднання.
 
 Таким чином, ви побачите події `open` -> `message` -> `close`.
 
@@ -88,7 +88,7 @@ Sec-WebSocket-Key: Iv8io/9s+lYFgZWcXczP8Q==
 Sec-WebSocket-Version: 13
 ```
 
-- `Origin` -- джерело клієнтської сторінки, наприклад `https://javascript.info`. Об’єкти WebSocket є перехресними за своєю природою. Немає спеціальних заголовків чи інших обмежень. Старі сервери все одно не можуть обробляти WebSocket, тому проблем із сумісністю немає. Але заголовок `Origin` важливий, оскільки він дозволяє серверу вирішувати, спілкуватися чи ні WebSocket з цим веб-сайтом.
+- `Origin` -- джерело клієнтської сторінки, наприклад `https://javascript.info`. Об'єкти WebSocket є перехресними за своєю природою. Немає спеціальних заголовків чи інших обмежень. Старі сервери все одно не можуть обробляти WebSocket, тому проблем із сумісністю немає. Але заголовок `Origin` важливий, оскільки він дозволяє серверу вирішувати, спілкуватися чи ні WebSocket з цим веб-сайтом.
 - `Connection: Upgrade` -- сигналізує про те, що клієнт хоче змінити протокол.
 - `Upgrade: websocket` -- запитуваний протокол - "websocket".
 - `Sec-WebSocket-Key` -- випадковий ключ, згенерований браузером, який використовується для забезпечення підтримки сервером протоколу WebSocket. Він є випадковим, щоб проксі-сервери не кешували будь-які наступні повідомлення.
@@ -117,11 +117,11 @@ Sec-WebSocket-Accept: hsBlbuDTkk24srzEOTBUlZAlC2g=
 
 Наприклад:
 
-- `Sec-WebSocket-Extensions: deflate-frame` означає, що браузер підтримує стиснення даних. Розширення(extension) -- це щось, пов’язане з передачею даних, тобто функціональність, яка розширює протокол WebSocket. Заголовок `Sec-WebSocket-Extensions` автоматично надсилається браузером зі списком усіх розширень, які він підтримує.
+- `Sec-WebSocket-Extensions: deflate-frame` означає, що браузер підтримує стиснення даних. Розширення(extension) -- це щось, пов'язане з передачею даних, тобто функціональність, яка розширює протокол WebSocket. Заголовок `Sec-WebSocket-Extensions` автоматично надсилається браузером зі списком усіх розширень, які він підтримує.
 
 - `Sec-WebSocket-Protocol: soap, wamp` означає, що ми хочемо передати не просто будь-які дані, а дані в [SOAP](http://en.wikipedia.org/wiki/SOAP) або WAMP ("The WebSocket Application Messaging Protocol"). Підпротоколи WebSocket зареєстровані в [каталозі IANA](https://www.iana.org/assignments/websocket/websocket.xml). Отже, цей заголовок описує формати даних, які ми збираємося використовувати.
 
-    Цей необов’язковий заголовок встановлюється за допомогою другого параметра `new WebSocket` у вигляді масиву підпротоколів. Наприклад, якщо ми хочемо використовувати SOAP або WAMP:
+    Цей необов'язковий заголовок встановлюється за допомогою другого параметра `new WebSocket` у вигляді масиву підпротоколів. Наприклад, якщо ми хочемо використовувати SOAP або WAMP:
 
     ```js
     let socket = new WebSocket("wss://javascript.info/chat", ["soap", "wamp"]);
@@ -162,12 +162,12 @@ Sec-WebSocket-Protocol: soap
 
 ## Передача даних
 
-Зв’язок WebSocket складається з "фреймів" -- фрагментів даних, які можуть бути відправлені будь-якою стороною і можуть бути кількох видів:
+Зв'язок WebSocket складається з "фреймів" -- фрагментів даних, які можуть бути відправлені будь-якою стороною і можуть бути кількох видів:
 
 - "текстові фрейми" -- містять текстові дані, які сторони надсилають одна одній.
 - "фрейми двійкових даних" -- містять бінарні дані, які сторони надсилають одна одній.
-- "ping/pong фрейми" використовуються для перевірки з’єднання, надсилаються сервером, браузер реагує на них автоматично.
-- також існує "фрейм закриття з’єднання" та кілька інших сервісних фреймів.
+- "ping/pong фрейми" використовуються для перевірки з'єднання, надсилаються сервером, браузер реагує на них автоматично.
+- також існує "фрейм закриття з'єднання" та кілька інших сервісних фреймів.
 
 У браузері ми безпосередньо працюємо тільки з текстовими або двійковими фреймами.
 
@@ -177,9 +177,9 @@ Sec-WebSocket-Protocol: soap
 
 **Коли ми отримуємо дані, текст завжди надходить у вигляді рядка. А для двійкових даних ми можемо вибирати між форматами `Blob` і `ArrayBuffer`.**
 
-Це встановлюється властивістю `socket.binaryType`, і типово використовується `"blob"`, тому двійкові дані надходять як об’єкти `Blob`.
+Це встановлюється властивістю `socket.binaryType`, і типово використовується `"blob"`, тому двійкові дані надходять як об'єкти `Blob`.
 
-[Blob](info:blob) -- це двійковий об’єкт високого рівня, він безпосередньо інтегрується з тегами `<a>`, `<img>` та іншими, тому це нормальне типове значення. Але для двійкової обробки, щоб отримати доступ до окремих байтів даних, ми можемо змінити його на `"arraybuffer"`:
+[Blob](info:blob) -- це двійковий об'єкт високого рівня, він безпосередньо інтегрується з тегами `<a>`, `<img>` та іншими, тому це нормальне типове значення. Але для двійкової обробки, щоб отримати доступ до окремих байтів даних, ми можемо змінити його на `"arraybuffer"`:
 
 ```js
 socket.binaryType = "arraybuffer";
@@ -192,7 +192,7 @@ socket.onmessage = (event) => {
 
 Уявіть, що наш додаток генерує багато даних для надсилання. Але у користувача повільне підключення до мережі, можливо, через мобільний інтернет чи погане покриття за містом.
 
-Ми можемо викликати `socket.send(data)` знову і знову. Але дані буферизуються (зберігаються) у пам’яті та надсилатимуться лише настільки швидко, наскільки це дозволяє швидкість мережі.
+Ми можемо викликати `socket.send(data)` знову і знову. Але дані буферизуються (зберігаються) у пам'яті та надсилатимуться лише настільки швидко, наскільки це дозволяє швидкість мережі.
 
 Властивість `socket.bufferedAmount` зберігає, скільки байтів залишилося у буфері в цей момент, очікуючи відправлення мережею.
 
@@ -209,17 +209,17 @@ setInterval(() => {
 ```
 
 
-## Закриття з’єднання
+## Закриття з'єднання
 
-Зазвичай, коли одна зі сторін хоче закрити з’єднання (і браузер, і сервер мають рівні права), вони надсилають "фрейм закриття з’єднання" з цифровим кодом і текстовою причиною.
+Зазвичай, коли одна зі сторін хоче закрити з'єднання (і браузер, і сервер мають рівні права), вони надсилають "фрейм закриття з'єднання" з цифровим кодом і текстовою причиною.
 
 Метод для цього:
 ```js
 socket.close([code], [reason]);
 ```
 
-- `code` це спеціальний код закриття WebSocket (необов’язковий параметр)
-- `reason` це рядок, який описує причину закриття (необов’язковий параметр)
+- `code` це спеціальний код закриття WebSocket (необов'язковий параметр)
+- `reason` це рядок, який описує причину закриття (необов'язковий параметр)
 
 Після цього інша сторона в обробнику події `close` отримує код і причину, наприклад:
 
@@ -238,7 +238,7 @@ socket.onclose = event => {
 Найпоширеніші значення коду закриття:
 
 - `1000` -- типове значення, звичайне закриття (використовується, якщо не вказано `code`),
-- `1006` -- немає можливості встановити такий код вручну, вказує на те, що з’єднання було втрачено (немає закриваючого фрейму).
+- `1006` -- немає можливості встановити такий код вручну, вказує на те, що з'єднання було втрачено (немає закриваючого фрейму).
 
 Є й інші коди, наприклад:
 
@@ -252,7 +252,7 @@ socket.onclose = event => {
 Коди WebSocket дещо схожі на коди HTTP, але відрізняються. Зокрема, будь-які коди менше `1000` зарезервовані. Якщо ми спробуємо встановити такий код, виникне помилка.
 
 ```js
-// у разі розриву зв’язку
+// у разі розриву зв'язку
 socket.onclose = event => {
   // event.code === 1006
   // event.reason === ""
@@ -261,14 +261,14 @@ socket.onclose = event => {
 ```
 
 
-## Стан з’єднання
+## Стан з'єднання
 
-Щоб отримати стан з’єднання, додатково є властивість `socket.readyState` зі значеннями:
+Щоб отримати стан з'єднання, додатково є властивість `socket.readyState` зі значеннями:
 
-- **`0`** -- "CONNECTING": з’єднання ще не встановлено,
+- **`0`** -- "CONNECTING": з'єднання ще не встановлено,
 - **`1`** -- "OPEN": обмін даними,
-- **`2`** -- "CLOSING": з’єднання закривається,
-- **`3`** -- "CLOSED": з’єднання закрите.
+- **`2`** -- "CLOSING": з'єднання закривається,
+- **`3`** -- "CLOSED": з'єднання закрите.
 
 
 ## Приклад чату
@@ -316,14 +316,14 @@ socket.onmessage = function(event) {
 }
 ```
 
-Серверний код трохи виходить за рамки поточної теми. Тут ми будемо використовувати Node.js, але вам не обов’язково це робити. Інші платформи також мають свої засоби для роботи з WebSocket.
+Серверний код трохи виходить за рамки поточної теми. Тут ми будемо використовувати Node.js, але вам не обов'язково це робити. Інші платформи також мають свої засоби для роботи з WebSocket.
 
 Алгоритм на стороні сервера буде таким:
 
 1. Створити `clients = new Set()` -- набір сокетів.
 2. Для кожного прийнятого веб-сокета додати його до набору `clients.add(socket)` і налаштувати прослуховувач події `message`, щоб отримати повідомлення.
 3. Коли отримано повідомлення: переглянути клієнтів та надіслати його всім.
-4. Коли з’єднання закрито: `clients.delete(socket)`.
+4. Коли з'єднання закрито: `clients.delete(socket)`.
 
 ```js
 const ws = new require('ws');
@@ -332,7 +332,7 @@ const wss = new ws.Server({noServer: true});
 const clients = new Set();
 
 http.createServer((req, res) => {
-  // тут ми обробляємо лише з’єднання websocket
+  // тут ми обробляємо лише з'єднання websocket
   // у реальному проекті у нас був би також код для обробки запитів, які не є веб-сокетами
   wss.handleUpgrade(req, req.socket, Buffer.alloc(0), onSocketConnect);
 });
@@ -363,7 +363,7 @@ function onSocketConnect(ws) {
 
 ## Підсумки
 
-WebSocket -- це сучасний спосіб мати постійне з’єднання браузер-сервер.
+WebSocket -- це сучасний спосіб мати постійне з'єднання браузер-сервер.
 
 - WebSockets не має кросдоменних обмежень.
 - Він добре підтримується в браузерах.
diff --git a/5-network/12-server-sent-events/article.md b/5-network/12-server-sent-events/article.md
index 4d4a91548..dfb45b7f1 100644
--- a/5-network/12-server-sent-events/article.md
+++ b/5-network/12-server-sent-events/article.md
@@ -1,8 +1,8 @@
 # Server Sent Events
 
-Специфікація [Server-Sent Events](https://html.spec.whatwg.org/multipage/comms.html#the-eventsource-interface) описує вбудований клас `EventSource`, який підтримує з’єднання з сервером і дозволяє отримувати від нього події.
+Специфікація [Server-Sent Events](https://html.spec.whatwg.org/multipage/comms.html#the-eventsource-interface) описує вбудований клас `EventSource`, який підтримує з'єднання з сервером і дозволяє отримувати від нього події.
 
-Подібно до `WebSocket`, з’єднання є постійним.
+Подібно до `WebSocket`, з'єднання є постійним.
 
 Але є кілька важливих відмінностей:
 
@@ -12,21 +12,21 @@
 | Двійкові та текстові дані | Тільки текст |
 | WebSocket протокол | Звичайний HTTP |
 
-`EventSource` є менш потужним способом зв’язку з сервером, ніж `WebSocket`.
+`EventSource` є менш потужним способом зв'язку з сервером, ніж `WebSocket`.
 
 Навіщо його використовувати?
 
 Основна причина: він простіший. У багатьох програмах потужність `WebSocket` є дещо занадто великою.
 
-Нам потрібно отримати потік даних із сервера: можливо, повідомлення в чаті чи ринкові ціни, чи що завгодно. Це те, у чому сильный `EventSource`. Також він підтримує автоматичне повторне з’єднання, що зазвичай потрібно реалізовувати вручну за допомогою `WebSocket`. Крім того, це звичайний добре відомий HTTP, а не новий протокол.
+Нам потрібно отримати потік даних із сервера: можливо, повідомлення в чаті чи ринкові ціни, чи що завгодно. Це те, у чому сильный `EventSource`. Також він підтримує автоматичне повторне з'єднання, що зазвичай потрібно реалізовувати вручну за допомогою `WebSocket`. Крім того, це звичайний добре відомий HTTP, а не новий протокол.
 
 ## Отримання повідомлень
 
 Щоб почати отримувати повідомлення, необхідно створити `new EventSource(url)`.
 
-Браузер приєднається до `url` і залишить з’єднання відкритим, чекаючи на події.
+Браузер приєднається до `url` і залишить з'єднання відкритим, чекаючи на події.
 
-Сервер повинен відповісти статусом 200 і заголовком `Content-Type: text/event-stream`, а потім зберегти з’єднання та писати повідомлення в спеціальному форматі, наприклад:
+Сервер повинен відповісти статусом 200 і заголовком `Content-Type: text/event-stream`, а потім зберегти з'єднання та писати повідомлення в спеціальному форматі, наприклад:
 
 ```
 data: Повідомлення 1
@@ -37,7 +37,7 @@ data: Повідомлення 3
 data: з двох рядків
 ```
 
-- Текст повідомлення йде після `data:`, пробіл після двокрапки необов’язковий.
+- Текст повідомлення йде після `data:`, пробіл після двокрапки необов'язковий.
 - Повідомлення розділені подвійними розривами рядків `\n\n`.
 - Щоб надіслати розрив рядка `\n`, ми можемо негайно надіслати ще одне `data:` (3-тє повідомлення вище).
 
@@ -85,27 +85,27 @@ let source = new EventSource("https://another-site.com/events", {
 Будь ласка, перегляньте розділ <info:fetch-crossorigin>, щоб дізнатися більше про заголовки з перехресними джерелами.
 
 
-## Повторне з’єднання
+## Повторне з'єднання
 
-Після створення `new EventSource` приєднується до сервера, і якщо з’єднання розривається -- автоматично приєднується знову.
+Після створення `new EventSource` приєднується до сервера, і якщо з'єднання розривається -- автоматично приєднується знову.
 
 Це дуже зручно, оскільки не потрібно дбати про це додатково.
 
-Між повторними з’єднаннями є невелика затримка, типово кілька секунд.
+Між повторними з'єднаннями є невелика затримка, типово кілька секунд.
 
 Сервер може встановити рекомендовану затримку, використовуючи `retry:` у відповідь (у мілісекундах):
 
 ```js
 retry: 15000
-data: Привіт, я встановив затримку повторного з’єднання на 15 секунд
+data: Привіт, я встановив затримку повторного з'єднання на 15 секунд
 ```
 
 `retry:` може надсилатись як разом із деякими даними, так і окремим повідомленням.
 
-Браузер повинен зачекати вказану кількість мілісекунд перед повторним з’єднанням. Або довше, напр. якщо браузер знає (з ОС), що на даний момент немає з’єднання із мережею, він може зачекати, доки з’єднання з’явиться, а потім повторити спробу.
+Браузер повинен зачекати вказану кількість мілісекунд перед повторним з'єднанням. Або довше, напр. якщо браузер знає (з ОС), що на даний момент немає з'єднання із мережею, він може зачекати, доки з'єднання з'явиться, а потім повторити спробу.
 
-- Якщо сервер бажає, щоб браузер припинив повторне з’єднання, він повинен відповісти HTTP статусом 204.
-- Якщо браузер хоче закрити з’єднання, він повинен викликати `eventSource.close()`:
+- Якщо сервер бажає, щоб браузер припинив повторне з'єднання, він повинен відповісти HTTP статусом 204.
+- Якщо браузер хоче закрити з'єднання, він повинен викликати `eventSource.close()`:
 
 ```js
 let eventSource = new EventSource(...);
@@ -113,17 +113,17 @@ let eventSource = new EventSource(...);
 eventSource.close();
 ```
 
-Крім того, не буде повторного з’єднання, якщо відповідь містить неправильний `Content-Type` або його статус HTTP відрізняється від 301, 307, 200 і 204. У таких випадках буде створено подію `"error"`, і браузер не підключатиметься повторно.
+Крім того, не буде повторного з'єднання, якщо відповідь містить неправильний `Content-Type` або його статус HTTP відрізняється від 301, 307, 200 і 204. У таких випадках буде створено подію `"error"`, і браузер не підключатиметься повторно.
 
 ```smart
-Коли з’єднання остаточно закрито, його неможливо відкрити знову. Якщо ми хочемо знову під’єднатися, доведеться створити новий `EventSource`.
+Коли з'єднання остаточно закрито, його неможливо відкрити знову. Якщо ми хочемо знову під'єднатися, доведеться створити новий `EventSource`.
 ```
 
 ## Ідентифікатор повідомлення
 
-Коли з’єднання розривається через проблеми з мережею, жодна сторона не може бути впевнена, які повідомлення були отримані, а які ні.
+Коли з'єднання розривається через проблеми з мережею, жодна сторона не може бути впевнена, які повідомлення були отримані, а які ні.
 
-Щоб правильно відновити з’єднання, кожне повідомлення має мати поле `id`, наприклад:
+Щоб правильно відновити з'єднання, кожне повідомлення має мати поле `id`, наприклад:
 
 ```
 data: Повідомлення 1
@@ -140,32 +140,32 @@ id: 3
 Коли браузер отримає повідомлення з `id:`:
 
 - Встановлюється значення властивості `eventSource.lastEventId`.
-- Після повторного з’єднання надсилається заголовок `Last-Event-ID` з цим `id`, щоб сервер міг повторно надіслати наступні повідомлення.
+- Після повторного з'єднання надсилається заголовок `Last-Event-ID` з цим `id`, щоб сервер міг повторно надіслати наступні повідомлення.
 
 ```smart header="Зазначайте `id:` після `data:`"
 Зверніть увагу: `id` додається сервером під повідомленням `data` , щоб гарантувати, що `lastEventId` оновлюється після отримання повідомлення.
 ```
 
-## Статус з’єднання: readyState
+## Статус з'єднання: readyState
 
 Об'єкт `EventSource` має властивість `readyState`, яка має одне з трьох значень:
 
 ```js no-beautify
-EventSource.CONNECTING = 0; // з’єднання або повторне з’єднання
+EventSource.CONNECTING = 0; // з'єднання або повторне з'єднання
 EventSource.OPEN = 1;       // сполучено
-EventSource.CLOSED = 2;     // з’єднання закрите
+EventSource.CLOSED = 2;     // з'єднання закрите
 ```
 
-Коли створюється об’єкт або з’єднання розривається `EventSource.CONNECTING` (дорівнює `0`).
+Коли створюється об'єкт або з'єднання розривається `EventSource.CONNECTING` (дорівнює `0`).
 
 Ми можемо запитати цю властивість, щоб дізнатися стан `EventSource`.
 
 ## Типи подій
 
-Типово об’єкт `EventSource` генерує три події:
+Типово об'єкт `EventSource` генерує три події:
 
 - `message` -- отримане повідомлення, доступне як `event.data`.
-- `open` -- з’єднання відкрите.
+- `open` -- з'єднання відкрите.
 - `error` -- не вдалося приєднатися, напр. сервер повернув статус HTTP 500.
 
 Сервер може вказати інший тип події з `event: ...` на початку події.
@@ -200,19 +200,19 @@ eventSource.addEventListener('leave', event => {
 
 ## Повний приклад
 
-Ось сервер, який надсилає повідомлення з `1`, `2`, `3`, потім `bye` та розриває з’єднання.
+Ось сервер, який надсилає повідомлення з `1`, `2`, `3`, потім `bye` та розриває з'єднання.
 
-Потім браузер автоматично відновить з’єднання.
+Потім браузер автоматично відновить з'єднання.
 
 [codetabs src="eventsource"]
 
 ## Підсумки
 
-Об’єкт `EventSource` автоматично встановлює постійне з’єднання і дозволяє серверу надсилати повідомлення через нього.
+Об'єкт `EventSource` автоматично встановлює постійне з'єднання і дозволяє серверу надсилати повідомлення через нього.
 
 Він пропонує:
 - Автоматичне перепідключення, з затримкою `retry` що налаштовується.
-- Ідентифікатори повідомлень для відновлення подій, останній отриманий id надсилається в заголовку `Last-Event-ID` після повторного з’єднання.
+- Ідентифікатори повідомлень для відновлення подій, останній отриманий id надсилається в заголовку `Last-Event-ID` після повторного з'єднання.
 - Поточний стан знаходиться у властивості `readyState`.
 
 Це робить `EventSource` життєздатною альтернативою `WebSocket`, оскільки останній є більш низькорівневим і не має таких вбудованих функцій (хоча їх можна реалізувати).
@@ -231,18 +231,18 @@ let source = new EventSource(url, [credentials]);
 
 Загальна безпека між різними джерелами така ж, як і для `fetch` та інших мережевих методів.
 
-### Властивості об’єкта `EventSource`
+### Властивості об'єкта `EventSource`
 
 `readyState`
-: Поточний стан з’єднання: або `EventSource.CONNECTING (=0)`, `EventSource.OPEN (=1)` чи `EventSource.CLOSED (=2)`.
+: Поточний стан з'єднання: або `EventSource.CONNECTING (=0)`, `EventSource.OPEN (=1)` чи `EventSource.CLOSED (=2)`.
 
 `lastEventId`
-: Останній отриманний `id`. Після повторного з’єднання браузер надсилає його в заголовку `Last-Event-ID`.
+: Останній отриманний `id`. Після повторного з'єднання браузер надсилає його в заголовку `Last-Event-ID`.
 
 ### Методи
 
 `close()`
-: Замикає з’єднання.
+: Замикає з'єднання.
 
 ### Події
 
@@ -250,12 +250,12 @@ let source = new EventSource(url, [credentials]);
 : Повідомлення отримано, дані в `event.data`.
 
 `open`
-: З’єднання встановлено.
+: З'єднання встановлено.
 
 `error`
-: У разі помилки, включає як втрачене з’єднання (буде автоматично відновлено), так і фатальні помилки. Ми можемо перевірити `readyState`, щоб побачити, чи робиться спроба повторного з’єднання.
+: У разі помилки, включає як втрачене з'єднання (буде автоматично відновлено), так і фатальні помилки. Ми можемо перевірити `readyState`, щоб побачити, чи робиться спроба повторного з'єднання.
 
-Сервер може встановити спеціальне ім’я події в `event:`. Такі події слід обробляти за допомогою `addEventListener`, а не `on<event>`.
+Сервер може встановити спеціальне ім'я події в `event:`. Такі події слід обробляти за допомогою `addEventListener`, а не `on<event>`.
 
 ### Формат відповіді сервера
 
@@ -264,8 +264,8 @@ let source = new EventSource(url, [credentials]);
 Повідомлення може мати такі поля:
 
 - `data:` -- у тілі повідомлення, послідовність кількох `data` інтерпретується як одне повідомлення з `\n` між його частинами.
-- `id:` -- поновлює `lastEventId`, надісланий у `Last-Event-ID` під час повторного з’єднання.
-- `retry:` -- радить затримку повторного з’єднання у мс. Немає способу встановити його за допомогою JavaScript.
-- `event:` -- ім’я події має передувати `data:`.
+- `id:` -- поновлює `lastEventId`, надісланий у `Last-Event-ID` під час повторного з'єднання.
+- `retry:` -- радить затримку повторного з'єднання у мс. Немає способу встановити його за допомогою JavaScript.
+- `event:` -- ім'я події має передувати `data:`.
 
 Повідомлення може містити один або кілька рядків у будь-якому порядку, але `id:` зазвичай йде останнім..

From 41d03b749ddca9b7313ddd813de7d590842de770 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:27 +0300
Subject: [PATCH 06/11] =?UTF-8?q?feat(6-data-storage):=20Changed=20all=20a?=
 =?UTF-8?q?postrophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 6-data-storage/01-cookie/article.md       |  22 +--
 6-data-storage/02-localstorage/article.md |  54 +++----
 6-data-storage/03-indexeddb/article.md    | 164 +++++++++++-----------
 3 files changed, 120 insertions(+), 120 deletions(-)

diff --git a/6-data-storage/01-cookie/article.md b/6-data-storage/01-cookie/article.md
index 35bfe1763..5b6e9bd96 100644
--- a/6-data-storage/01-cookie/article.md
+++ b/6-data-storage/01-cookie/article.md
@@ -52,7 +52,7 @@ alert(document.cookie); // показати всі файли cookies
 
 Якщо ви запустите код вище, то напевно побачите декілька файлів cookies. Це тому що операція `document.cookie=` оновлює не всі файли cookies, а лише вказані файли з іменем `user`.
 
-Технічно, ім’я та значення можуть містити будь-які символи. Щоб зберегти правильне форматування, вони повинні бути кодовані за допомогою вбудованої функції `encodeURIComponent`.
+Технічно, ім'я та значення можуть містити будь-які символи. Щоб зберегти правильне форматування, вони повинні бути кодовані за допомогою вбудованої функції `encodeURIComponent`.
 
 ```js run
 // спеціальні символи (пробіли, кирилиця), потребують кодування
@@ -158,7 +158,7 @@ document.cookie = "user=John; expires=" + date;
 
 Це альтернатива `expires`, який вказує термін придатності cookie в секундах з поточного моменту.
 
-Як встановлено 0 або від’ємне значення, то файл cookie буде видалено:
+Як встановлено 0 або від'ємне значення, то файл cookie буде видалено:
 
 ```js
 // файл cookie буде видалено через 1 годину
@@ -174,7 +174,7 @@ document.cookie = "user=John; max-age=0";
 
 Файл cookie повинен передаватися виключно по HTTPS-протоколу.
 
-**За замовчуванням, якщо ми створимо файл cookie на `http://site.com`, тоді він автоматично з’явиться на `https://site.com` та навпаки.**
+**За замовчуванням, якщо ми створимо файл cookie на `http://site.com`, тоді він автоматично з'явиться на `https://site.com` та навпаки.**
 
 Тобто файли cookie базуються на домені, вони не залежать від протоколів.
 
@@ -206,7 +206,7 @@ document.cookie = "user=John; secure";
 
 Звісно, справжні банкові системи захищені від цього. У всіх згенерованих сайтом `bank.com` формах є спеціальне поле, так взваний "токен захисту від XSRF", який не може бути ані згенерований зловмисним сайтом, ані вилучений з віддаленої сторінки. Зловмисник може спробувати відправити форму туди, але не може отримати дані назад. Сайт `bank.com` перевіряє кожну отриману форму на наявність даного токену.
 
-Проте такий захист вимагає більше часу на реалізацію. Нам потрібно переконатися, що кожна форма несе в собі обов’язкове поле з токеном, окрім того потрібно перевіряти всі запити.
+Проте такий захист вимагає більше часу на реалізацію. Нам потрібно переконатися, що кожна форма несе в собі обов'язкове поле з токеном, окрім того потрібно перевіряти всі запити.
 
 ### Параметр samesite
 
@@ -305,7 +305,7 @@ function getCookie(name) {
 
 ### setCookie(name, value, options)
 
-Встановлює файл cookie з заданим ім’ям `name`, значенням `value`, та типовим параметром `path=/` (можна редагувати, щоб додати інші типові значення):
+Встановлює файл cookie з заданим ім'ям `name`, значенням `value`, та типовим параметром `path=/` (можна редагувати, щоб додати інші типові значення):
 
 ```js run
 function setCookie(name, value, options = {}) {
@@ -339,7 +339,7 @@ setCookie('user', 'John', {secure: true, 'max-age': 3600});
 
 ### deleteCookie(name)
 
-Щоб видалили файли cookie, ми можем викликати функцію вказавши від’ємне значення в параметрі `max-age`:
+Щоб видалили файли cookie, ми можем викликати функцію вказавши від'ємне значення в параметрі `max-age`:
 
 ```js
 function deleteCookie(name) {
@@ -350,7 +350,7 @@ function deleteCookie(name) {
 ```
 
 ```warn header="Операції оновлення або видалення повинні використовувати ті самі адресу та домен."
-Зауважте: коли ми оновлюємо чи видаляємо файли cookie, ми повинні використовувати ті самі адресу та доменне ім’я, що і при встановленні.
+Зауважте: коли ми оновлюємо чи видаляємо файли cookie, ми повинні використовувати ті самі адресу та доменне ім'я, що і при встановленні.
 ```
 
 Все разом: [cookie.js](cookie.js).
@@ -375,7 +375,7 @@ function deleteCookie(name) {
     ![](cookie-third-party-3.svg)
 
 
-Сторонні файли cookie традиційно використовуються для відслідковування статистики відвідувань та показу реклами. Вони прив’язані до початкового домену, тому `ads.com` може відслідковувати одного й того ж користувача при переході між сайтами, якщо всі вони мають до нього доступ.
+Сторонні файли cookie традиційно використовуються для відслідковування статистики відвідувань та показу реклами. Вони прив'язані до початкового домену, тому `ads.com` може відслідковувати одного й того ж користувача при переході між сайтами, якщо всі вони мають до нього доступ.
 
 Природньо, що деякі люди не хочуть щоб за ними стежили, тому браузери дозволяють відключити такі файли cookie.
 
@@ -392,7 +392,7 @@ function deleteCookie(name) {
 
 ## Додаток: GDPR
 
-Ця тема взагалі не пов’язана з JavaScript, це просто потрібно пам’ятати, налаштовуючи файли cookie.
+Ця тема взагалі не пов'язана з JavaScript, це просто потрібно пам'ятати, налаштовуючи файли cookie.
 
 У Європі існує законодавство під назвою GDPR, яке встановлює набір правил для вебсайтів щодо поваги до конфіденційності користувачів. Одне з цих правил — вимагати від користувача явного дозволу на відстеження файлів cookie.
 
@@ -413,14 +413,14 @@ function deleteCookie(name) {
      Щоб зробити це законно, вебсайт показує спливаюче модальне вікно для нових користувачів і вимагає від них погодитися на файли cookie. Тоді web-сайт може встановлювати їх і дозволити людям бачити контент. Але це може турбувати нових відвідувачів. Ніхто не любить бачити такі спливаючі модальні вікна, які вимагають взаємодії, замість перегляду контенту. Але GDPR вимагає чіткої угоди.
 
 
-GDPR стосується не лише файлів cookie, а й інших питань, пов’язаних із конфіденційністю, але це виходить за рамки даного розділу.
+GDPR стосується не лише файлів cookie, а й інших питань, пов'язаних із конфіденційністю, але це виходить за рамки даного розділу.
 
 
 ## Підсумки
 
 `document.cookie` забезпечує доступ до файлів cookies
 - операції запису змінюють лише вказані файли cookies.
-- ім’я та значення файлу cookie повинні бути закодовані.
+- ім'я та значення файлу cookie повинні бути закодовані.
 - один файл cookie не повинен перевищувати 4KB, 20+ файлів на один сайт (залежно від браузера).
 
 Параметри:
diff --git a/6-data-storage/02-localstorage/article.md b/6-data-storage/02-localstorage/article.md
index 3b263e7e6..0aaec5e90 100644
--- a/6-data-storage/02-localstorage/article.md
+++ b/6-data-storage/02-localstorage/article.md
@@ -1,16 +1,16 @@
 # LocalStorage, sessionStorage
 
-Об’єкти веб-сховища `localStorage` та `sessionStorage` дозволяють зберігати дані в браузері у вигляди пар ключ/значення.
+Об'єкти веб-сховища `localStorage` та `sessionStorage` дозволяють зберігати дані в браузері у вигляди пар ключ/значення.
 
 Що цікаво, дані зберігаються навіть після оновлення сторінки (для `sessionStorage`) і після повного закриття і нового відкриття вікна браузера (для `localStorage`). Ми скоро перевіримо це на практиці.
 
-Ми вже маємо `cookies`. Навіщо додаткові об’єкти?
+Ми вже маємо `cookies`. Навіщо додаткові об'єкти?
 
-- На відміну від файлів cookies, об’єкти веб-сховища не надсилаються на сервер із кожним запитом. Завдяки цьому ми можемо зберігати набагато більше даних. Більшість браузерів дозволяють принаймні 5 мегабайтів даних (або більше), користувач може навіть змінити цей об’єм.
-- Крім того, на відміну від файлів cookies, сервер не може маніпулювати об’єктами сховища через HTTP-заголовки. Все зроблено на JavaScript.
-- Сховище прив’язане до оригінального сайту (домен/протокол/порт). Таким чином, що різні протоколи або субдомени мають різні об’єкти зберігання, і не можуть отримати доступ до даних один одного.
+- На відміну від файлів cookies, об'єкти веб-сховища не надсилаються на сервер із кожним запитом. Завдяки цьому ми можемо зберігати набагато більше даних. Більшість браузерів дозволяють принаймні 5 мегабайтів даних (або більше), користувач може навіть змінити цей об'єм.
+- Крім того, на відміну від файлів cookies, сервер не може маніпулювати об'єктами сховища через HTTP-заголовки. Все зроблено на JavaScript.
+- Сховище прив'язане до оригінального сайту (домен/протокол/порт). Таким чином, що різні протоколи або субдомени мають різні об'єкти зберігання, і не можуть отримати доступ до даних один одного.
 
-Обидва об’єкти сховища забезпечують однакові методи та властивості:
+Обидва об'єкти сховища забезпечують однакові методи та властивості:
 
 - `setItem(key, value)` -- зберегти пару ключ/значення.
 - `getItem(key)` -- отримати значення за ключем.
@@ -46,9 +46,9 @@ alert( localStorage.getItem('test') ); // 1
 
 `localStorage` доступний для одного сайту в усіх відкритих вікнах, тому якщо ми встановимо дані в одному вікні, зміна стане видимою в іншому.
 
-## Доступ як до звичайного об’єкту
+## Доступ як до звичайного об'єкту
 
-Ми також можемо використовувати простий об’єктний спосіб отримання/запису даних, наприклад:
+Ми також можемо використовувати простий об'єктний спосіб отримання/запису даних, наприклад:
 
 ```js run
 // записати дані за ключем
@@ -63,7 +63,7 @@ delete localStorage.test;
 
 Це дозволено з історичних причин і в цілому працює, але зазвичай не рекомендується, оскільки:
 
-1. Якщо ключ створений користувачем, він може бути будь-яким, наприклад, `length` або `toString`, або іншим вбудованим методом `localStorage`. У цьому випадку `getItem/setItem` працює нормально, тоді як доступ через об’єкт ні:
+1. Якщо ключ створений користувачем, він може бути будь-яким, наприклад, `length` або `toString`, або іншим вбудованим методом `localStorage`. У цьому випадку `getItem/setItem` працює нормально, тоді як доступ через об'єкт ні:
 
     ```js run
     let key = 'length';
@@ -76,7 +76,7 @@ delete localStorage.test;
 
 Як ми бачили, методи забезпечують функцію "отримати/записати/видалити за ключем". Але як отримати всі збережені значення чи ключі?
 
-На жаль, об’єкти зберігання не є ітераційними.
+На жаль, об'єкти зберігання не є ітераційними.
 
 Один із способів -- працювати з ними як з масивом:
 
@@ -87,7 +87,7 @@ for(let i=0; i<localStorage.length; i++) {
 }
 ```
 
-Інший спосіб -- використати цикл `for key in localStorage`, так само, як для звичайних об’єктів.
+Інший спосіб -- використати цикл `for key in localStorage`, так само, як для звичайних об'єктів.
 
 Він перебирає ключі, але також виводить кілька вбудованих властивостей, які нам не потрібні:
 
@@ -118,20 +118,20 @@ for(let key of keys) {
 }
 ```
 
-Останній варіант працює, оскільки `Object.keys` повертає лише ключі, які належать об’єкту, ігноруючи прототип.
+Останній варіант працює, оскільки `Object.keys` повертає лише ключі, які належать об'єкту, ігноруючи прототип.
 
 ## Тільки рядки
 
 Зверніть увагу, що і ключ, і значення мають бути рядками.
 
-Якщо ми спробуємо використати будь-який інший тип, наприклад число або об’єкт, він автоматично перетвориться на рядок:
+Якщо ми спробуємо використати будь-який інший тип, наприклад число або об'єкт, він автоматично перетвориться на рядок:
 
 ```js run
 localStorage.user = {name: "John"};
 alert(localStorage.user); // [object Object]
 ```
 
-Однак ми можемо використати `JSON` для зберігання об’єктів:
+Однак ми можемо використати `JSON` для зберігання об'єктів:
 
 ```js run
 localStorage.user = JSON.stringify({name: "Тарас"});
@@ -141,16 +141,16 @@ let user = JSON.parse( localStorage.user );
 alert( user.name ); // Тарас
 ```
 
-Також можна перетворити весь об’єкт сховища на JSON рядок, наприклад, підчас налагодження коду:
+Також можна перетворити весь об'єкт сховища на JSON рядок, наприклад, підчас налагодження коду:
 
 ```js run
-// додано параметри форматування до JSON.stringify, щоб об’єкт виглядав краще
+// додано параметри форматування до JSON.stringify, щоб об'єкт виглядав краще
 alert( JSON.stringify(localStorage, null, 2) );
 ```
 
 ## sessionStorage
 
-Об’єкт `sessionStorage` використовується набагато рідше, ніж `localStorage`.
+Об'єкт `sessionStorage` використовується набагато рідше, ніж `localStorage`.
 
 Властивості та методи ті самі, але можливості більш обмежені:
 
@@ -175,7 +175,7 @@ alert( sessionStorage.getItem('test') ); // після оновлення: 1
 
 ...Але якщо ви відкриєте ту саму сторінку в іншій вкладці та спробуєте там ще раз, код вище поверне `null`, що означає "нічого не знайдено".
 
-Це саме тому, що `sessionStorage` прив’язаний не лише до сайту, а й до вкладки браузера. З цієї причини `sessionStorage` використовується не часто.
+Це саме тому, що `sessionStorage` прив'язаний не лише до сайту, а й до вкладки браузера. З цієї причини `sessionStorage` використовується не часто.
 
 ## Подія storage
 
@@ -185,9 +185,9 @@ alert( sessionStorage.getItem('test') ); // після оновлення: 1
 - `oldValue` – старе значення (`null`, якщо це новий ключ).
 - `newValue` – нове значення (`null`, якщо дані видалено).
 - `url` – URL-адреса документа, де відбулося оновлення.
-- `storageArea` – об’єкт `localStorage` або `sessionStorage`, де відбулося оновлення.
+- `storageArea` – об'єкт `localStorage` або `sessionStorage`, де відбулося оновлення.
 
-Важливо: подія запускається на всіх об’єктах `window`, де доступне сховище, крім того, що його викликало.
+Важливо: подія запускається на всіх об'єктах `window`, де доступне сховище, крім того, що його викликало.
 
 Давайте детальніше.
 
@@ -211,20 +211,20 @@ localStorage.setItem('now', ​​Date.now());
 
 Зверніть увагу, що подія також містить: `event.url` -- URL-адресу документа, в якому оновлено дані.
 
-Крім того, `event.storageArea` містить об’єкт сховища -- подія однакова для `sessionStorage` та `localStorage`, тому `event.storageArea` посилається на той, який було змінено. Ми навіть можемо захотіти щось змінити в ньому, "відреагувати" на зміни.
+Крім того, `event.storageArea` містить об'єкт сховища -- подія однакова для `sessionStorage` та `localStorage`, тому `event.storageArea` посилається на той, який було змінено. Ми навіть можемо захотіти щось змінити в ньому, "відреагувати" на зміни.
 
 **Це дозволяє різним вікнам одного сайту обмінюватися повідомленнями.**
 
-Сучасні браузери також підтримують [Broadcast channel API](mdn:/api/Broadcast_Channel_API), спеціальний API для міжвіконного зв’язку одного джерела, він більш повнофункціональний, але має меншу підтримку серед браузерів. Існують бібліотеки-поліфіли цього API на основі `localStorage`, що робить його доступним майже скрізь.
+Сучасні браузери також підтримують [Broadcast channel API](mdn:/api/Broadcast_Channel_API), спеціальний API для міжвіконного зв'язку одного джерела, він більш повнофункціональний, але має меншу підтримку серед браузерів. Існують бібліотеки-поліфіли цього API на основі `localStorage`, що робить його доступним майже скрізь.
 
 ## Підсумки
 
-Об’єкти веб-сховища `localStorage` та `sessionStorage` дозволяють зберігати ключ/значення в браузері.
+Об'єкти веб-сховища `localStorage` та `sessionStorage` дозволяють зберігати ключ/значення в браузері.
 
 - І `key`, і `value` мають бути рядками.
 - Ліміт становить 5 Мб+, залежить від браузера.
 - Дані не мають терміну зберіганя, тобто не видаляються.
-- Дані прив’язані до сайту (домен/порт/протокол).
+- Дані прив'язані до сайту (домен/порт/протокол).
 
 | `localStorage` | `sessionStorage` |
 |----------------|------------------|
@@ -240,10 +240,10 @@ API:
 - `key(index)` -- отримати ключ на заданій позиції.
 - `length` -- кількість збережених елементів.
 - Використовуйте `Object.keys`, щоб отримати всі ключі.
-- Ми маємо доступ до ключів як властивостей об’єкта та можемо ними маніпулювати, у цьому випадку подія `storage` не ініціюється.
+- Ми маємо доступ до ключів як властивостей об'єкта та можемо ними маніпулювати, у цьому випадку подія `storage` не ініціюється.
 
 Подія storage:
 
 - Спрацьовує на виклики `setItem`, `removeItem`, `clear`.
-- Містить усі дані про операцію (`key/oldValue/newValue`), URL-адресу документа та об’єкт сховища `storageArea`.
-- Спрацьовує для всіх об’єктів `window`, які мають доступ до сховища, крім того, який його створив (у межах вкладки для `sessionStorage`, глобально для `localStorage`).
+- Містить усі дані про операцію (`key/oldValue/newValue`), URL-адресу документа та об'єкт сховища `storageArea`.
+- Спрацьовує для всіх об'єктів `window`, які мають доступ до сховища, крім того, який його створив (у межах вкладки для `sessionStorage`, глобально для `localStorage`).
diff --git a/6-data-storage/03-indexeddb/article.md b/6-data-storage/03-indexeddb/article.md
index 6530df5ed..d6193a557 100644
--- a/6-data-storage/03-indexeddb/article.md
+++ b/6-data-storage/03-indexeddb/article.md
@@ -34,14 +34,14 @@ IndexedDB — це база даних, вбудована в браузер, н
 let openRequest = indexedDB.open(name, version);
 ```
 
-- `name` -- рядок, ім’я бази даних.
+- `name` -- рядок, ім'я бази даних.
 
 - `version` -- версія є цілим числом, типово `1` (пояснення нижче).
 
 У нас може бути багато баз даних з різними іменами, але всі вони існують лише в межах поточного вебсайту (протокол/домен/порт). Різні вебсайти не мають доступу до баз даних один одного.
 
-Виклик повертає об’єкт `openRequest`, ми повинні прослухати події на ньому:
-- `success`: база даних готова, в `openRequest.result`є "об’єкт бази даних", ми повинні використовувати його для подальших викликів.
+Виклик повертає об'єкт `openRequest`, ми повинні прослухати події на ньому:
+- `success`: база даних готова, в `openRequest.result`є "об'єкт бази даних", ми повинні використовувати його для подальших викликів.
 - `error`: не вдалося відкрити.
 - `upgradeneeded`: база даних готова, але її версія застаріла (див. нижче).
 
@@ -71,7 +71,7 @@ openRequest.onerror = function() {
 
 openRequest.onsuccess = function() {
   let db = openRequest.result;
-  // продовжити роботу з базою даних за допомогою об’єкта db
+  // продовжити роботу з базою даних за допомогою об'єкта db
 };
 ```
 
@@ -117,7 +117,7 @@ let deleteRequest = indexedDB.deleteDatabase(name)
 
 ### Проблема паралельного оновлення
 
-Оскільки ми говоримо про версійність, давайте розглянемо невеличку проблему пов’язану з цим.
+Оскільки ми говоримо про версійність, давайте розглянемо невеличку проблему пов'язану з цим.
 
 Скажімо:
 1. Відвідувач відкрив наш сайт у вкладці браузера з версією бази даних `1`.
@@ -128,11 +128,11 @@ let deleteRequest = indexedDB.deleteDatabase(name)
 
 Проблема полягає в тому, що база даних є спільною між двома вкладками, оскільки це той самий сайт, з того самого джерела. І це не може бути одночасно версія `1` і `2`. Щоб виконати оновлення до версії `2`, усі підключення до версії `1` мають бути закриті, включно з підключенням на першій вкладці.
 
-Щоб це організувати, подія `versionchange` запускається на "застарілому" об’єкті бази даних. Нам слід прислухатися до цього та закрити старе підключення до бази даних (і, ймовірно, запропонувати перезавантажити сторінку, щоб завантажити оновлений код).
+Щоб це організувати, подія `versionchange` запускається на "застарілому" об'єкті бази даних. Нам слід прислухатися до цього та закрити старе підключення до бази даних (і, ймовірно, запропонувати перезавантажити сторінку, щоб завантажити оновлений код).
 
-Якщо ми не прослухаємо подію `versionchange` і не закриємо старе з’єднання, то друге, нове з’єднання не буде встановлено. Об’єкт `openRequest` видаватиме подію `blocked` замість `success`. Тому друга вкладка не працюватиме.
+Якщо ми не прослухаємо подію `versionchange` і не закриємо старе з'єднання, то друге, нове з'єднання не буде встановлено. Об'єкт `openRequest` видаватиме подію `blocked` замість `success`. Тому друга вкладка не працюватиме.
 
-Ось код для правильної обробки паралельного оновлення. Він встановлює обробник `onversionchange`, який запускається, якщо поточне з’єднання з базою даних стає застарілим (версія db оновлюється в іншому місці), і закриває з’єднання.
+Ось код для правильної обробки паралельного оновлення. Він встановлює обробник `onversionchange`, який запускається, якщо поточне з'єднання з базою даних стає застарілим (версія db оновлюється в іншому місці), і закриває з'єднання.
 
 ```js
 let openRequest = indexedDB.open("store", 2);
@@ -166,27 +166,27 @@ openRequest.onblocked = function() {
 ...Інакше кажучи, тут ми робимо дві речі:
 
 1. Слухач `db.onversionchange` повідомляє нас про спробу паралельного оновлення, якщо поточна версія бази даних стає застарілою.
-2. Слухач `openRequest.onblocked` інформує нас про протилежну ситуацію: є підключення до застарілої версії в іншому місці, і воно не закривається, тому нове з’єднання неможливо встановити.
+2. Слухач `openRequest.onblocked` інформує нас про протилежну ситуацію: є підключення до застарілої версії в іншому місці, і воно не закривається, тому нове з'єднання неможливо встановити.
 
-Ми можемо обробляти подібні речі більш витончено в `db.onversionchange`, запропонувати відвідувачу зберегти дані до закриття з’єднання.
+Ми можемо обробляти подібні речі більш витончено в `db.onversionchange`, запропонувати відвідувачу зберегти дані до закриття з'єднання.
 
 Або, альтернативним підходом було б не закривати базу даних у `db.onversionchange`, а замість цього використовувати обробник `onblocked` (у новій вкладці), щоб попередити відвідувача про те, що новішу версію не можна завантажити, доки він не закриє іншу вкладку.
 
 Ці зіткнення оновлень трапляються рідко, але ми повинні принаймні мати певну обробку для них, обробник `onblocked`, щоб запобігти безшумній смерті нашого сценарію.
 
-## Сховище об’єктів
+## Сховище об'єктів
 
-Щоб зберегти щось у IndexedDB, нам потріне *сховище об’єктів*.
+Щоб зберегти щось у IndexedDB, нам потріне *сховище об'єктів*.
 
-Сховище об’єктів є основною концепцією IndexedDB. Аналоги в інших базах даних називаються «таблицями» або «колекціями». Саме там зберігаються дані. База даних може мати кілька сховищ: одне для користувачів, інше для товарів тощо.
+Сховище об'єктів є основною концепцією IndexedDB. Аналоги в інших базах даних називаються «таблицями» або «колекціями». Саме там зберігаються дані. База даних може мати кілька сховищ: одне для користувачів, інше для товарів тощо.
 
-Незважаючи на те, що це називають «сховищем об’єктів», примітиви також можна зберігати.
+Незважаючи на те, що це називають «сховищем об'єктів», примітиви також можна зберігати.
 
-**Ми можемо зберігати практично будь-які значення, включаючи складні об’єкти.**
+**Ми можемо зберігати практично будь-які значення, включаючи складні об'єкти.**
 
-IndexedDB використовує [стандартний алгоритм серіалізації](https://www.w3.org/TR/html53/infrastructure.html#section-structuredserializeforstorage) щоб клонувати та зберігати об’єкт. Це як `JSON.stringify`, але потужніший, здатний зберігати набагато більше типів даних.
+IndexedDB використовує [стандартний алгоритм серіалізації](https://www.w3.org/TR/html53/infrastructure.html#section-structuredserializeforstorage) щоб клонувати та зберігати об'єкт. Це як `JSON.stringify`, але потужніший, здатний зберігати набагато більше типів даних.
 
-Приклад об’єкта, який не можливо зберегти: об’єкт з круговими посиланнями. Такі об’єкти не можна серіалізувати. `JSON.stringify` також не придатний для таких об’єктів.
+Приклад об'єкта, який не можливо зберегти: об'єкт з круговими посиланнями. Такі об'єкти не можна серіалізувати. `JSON.stringify` також не придатний для таких об'єктів.
 
 **Для кожного значення в сховищі має бути унікальний "ключ".**     
 
@@ -194,11 +194,11 @@ IndexedDB використовує [стандартний алгоритм се
 
 ![](indexeddb-structure.svg)
 
-Як побачимо незабаром, ми можемо надати ключ, коли додамо значення до сховища, подібне до `localStorage`. Але коли ми зберігаємо об’єкти, IndexedDB дозволяє налаштувати властивість об’єкта як ключ, що набагато зручніше. Або ми можемо автоматично згенерувати ключі.
+Як побачимо незабаром, ми можемо надати ключ, коли додамо значення до сховища, подібне до `localStorage`. Але коли ми зберігаємо об'єкти, IndexedDB дозволяє налаштувати властивість об'єкта як ключ, що набагато зручніше. Або ми можемо автоматично згенерувати ключі.
 
-Але спочатку нам потрібно створити сховище об’єктів.
+Але спочатку нам потрібно створити сховище об'єктів.
 
-Синтаксис створення сховища об’єктів:
+Синтаксис створення сховища об'єктів:
 
 ```js
 db.createObjectStore(name[, keyOptions]);
@@ -207,26 +207,26 @@ db.createObjectStore(name[, keyOptions]);
 Зауважте, що операція синхронна, та не потребує `await`.
 
 - `name` -- назва сховища, наприклад. `"books"` для книжок,
-- `keyOptions` є необов’язковим об’єктом з однією з двох властивостей:
-  - `keyPath` -- шлях до властивості об’єкта, який IndexedDB використовуватиме як ключ, напр. `id`.
-  - `autoIncrement` -- якщо `true`, тоді ключ для щойно збереженого об’єкта генерується автоматично у вигляді постійно зростаючого числа.
+- `keyOptions` є необов'язковим об'єктом з однією з двох властивостей:
+  - `keyPath` -- шлях до властивості об'єкта, який IndexedDB використовуватиме як ключ, напр. `id`.
+  - `autoIncrement` -- якщо `true`, тоді ключ для щойно збереженого об'єкта генерується автоматично у вигляді постійно зростаючого числа.
 
-Якщо ми не постачаємо `keyOptions`, тоді нам потрібно буде надати ключ явно пізніше, коли будемо зберігати об’єкт.
+Якщо ми не постачаємо `keyOptions`, тоді нам потрібно буде надати ключ явно пізніше, коли будемо зберігати об'єкт.
 
-Наприклад, це сховище об’єктів використовує властивість `id` як ключ:
+Наприклад, це сховище об'єктів використовує властивість `id` як ключ:
 
 ```js
 db.createObjectStore('books', {keyPath: 'id'});
 ```
 
-**Сховище об’єктів можна створити/змінити лише під час оновлення версії БД в обробнику `upgradeneeded`.**
+**Сховище об'єктів можна створити/змінити лише під час оновлення версії БД в обробнику `upgradeneeded`.**
 
-Це технічне обмеження. За межами обробника ми зможемо додавати/вилучати/оновлювати дані, але сховища об’єктів можна створювати/вилучати/змінювати лише під час оновлення версії.
+Це технічне обмеження. За межами обробника ми зможемо додавати/вилучати/оновлювати дані, але сховища об'єктів можна створювати/вилучати/змінювати лише під час оновлення версії.
 
 Щоб виконати оновлення версії бази даних, існує два основних підходи:
 
 1. Ми можемо реалізувати функції оновлення для кожної версії: від 1 до 2, від 2 до 3, від 3 до 4 тощо. Потім у `upgradeneeded` ми можемо порівняти версії (наприклад, стару 2, тепер 4) та запустити крок оновлення для кожної версії покроково, для кожної проміжної версії (2 до 3, потім від 3 до 4).
-2. Або ми можемо просто перевірити базу даних: отримати список існуючих сховищ об’єктів як `db.objectStoreNames`. Цим об’єктом є [DOMStringList](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#domstringlist) який надає метод `contains(name)` для перевірки існування. А потім ми можемо виконувати оновлення залежно від того, що існує, а що ні.
+2. Або ми можемо просто перевірити базу даних: отримати список існуючих сховищ об'єктів як `db.objectStoreNames`. Цим об'єктом є [DOMStringList](https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#domstringlist) який надає метод `contains(name)` для перевірки існування. А потім ми можемо виконувати оновлення залежно від того, що існує, а що ні.
 
 Для невеликих баз даних другий варіант може бути простішим.
 
@@ -244,7 +244,7 @@ openRequest.onupgradeneeded = function() {
 };
 ```
 
-Щоб видалити сховище об’єктів:
+Щоб видалити сховище об'єктів:
 
 ```js
 db.deleteObjectStore('books')
@@ -276,9 +276,9 @@ db.transaction(store[, type]);
 - `store` це назва сховища, до якого має отримати доступ транзакція, напр. `"books"`. Це може бути масив імен сховищ, якщо ми збираємося отримати доступ до кількох сховищ.
 - `type` – тип транзакції, один з:
   - `readonly` -- може лише читати дані, типово.
-  - `readwrite` -- може лише читати та записувати дані, але не створювати/видаляти/змінювати сховища об’єктів.
+  - `readwrite` -- може лише читати та записувати дані, але не створювати/видаляти/змінювати сховища об'єктів.
 
-Існує також тип транзакції `versionchange`: такі транзакції можуть робити все, але ми не можемо створити їх вручну. IndexedDB автоматично створює транзакцію `versionchange` під час відкриття бази даних для обробника `updateneeded`. Тому це єдине місце, де ми можемо оновлювати структуру бази даних, створювати/видаляти сховища об’єктів.
+Існує також тип транзакції `versionchange`: такі транзакції можуть робити все, але ми не можемо створити їх вручну. IndexedDB автоматично створює транзакцію `versionchange` під час відкриття бази даних для обробника `updateneeded`. Тому це єдине місце, де ми можемо оновлювати структуру бази даних, створювати/видаляти сховища об'єктів.
 
 ```smart header="Чому існують різні види транзакцій?"
 Продуктивність є причиною, чому транзакції мають бути позначені як `readonly` та `readwrite`. 
@@ -291,7 +291,7 @@ db.transaction(store[, type]);
 ```js
 let transaction = db.transaction("books", "readwrite"); // (1)
 
-// отримати сховище об’єктів для роботи з ним
+// отримати сховище об'єктів для роботи з ним
 *!*
 let books = transaction.objectStore("books"); // (2)
 */!*
@@ -318,26 +318,26 @@ request.onerror = function() {
 Ось чотири основні кроки:
 
 1. Створіть транзакцію, вказавши всі сховища, в які вона збирається отримати доступ `(1)`.
-2. Отримайте об’єкт магазину за допомогою `transaction.objectStore(name)` `(2)`.
-3. Виконайте запит до сховища об’єктів `books.add(book)` `(3)`.
+2. Отримайте об'єкт магазину за допомогою `transaction.objectStore(name)` `(2)`.
+3. Виконайте запит до сховища об'єктів `books.add(book)` `(3)`.
 4. ...Обробіть запит успішно/помилка `(4)`, потім можливо робити інші запити, якщо потрібно.
 
-Сховища об’єктів підтримують два методи збереження значення:
+Сховища об'єктів підтримують два методи збереження значення:
 
 - **put(value, [key])**
-    Додайте `value` до сховища. `Key` надається лише в тому випадку, якщо в сховищі об’єктів не було параметра `keyPath` або `autoIncrement`. `keyPath` чи `autoIncrement` опція. Якщо вже є значення з таким самим ключем, воно буде замінено.
+    Додайте `value` до сховища. `Key` надається лише в тому випадку, якщо в сховищі об'єктів не було параметра `keyPath` або `autoIncrement`. `keyPath` чи `autoIncrement` опція. Якщо вже є значення з таким самим ключем, воно буде замінено.
 
 - **add(value, [key])**
     Те саме що `put`, але якщо вже є значення з тим самим ключем, запит не вдається, і генерується помилка з назвою `"ConstraintError"`.
 
 Подібно до відкриття бази даних, ми можемо відправити запит: `books.add(book)`, а потім чекати події `success/error`.
 
-- `request.result` для `add` є ключем нового об’єкта.
+- `request.result` для `add` є ключем нового об'єкта.
 - Помилкою, якщо є, буде `request.error`.
 
 ## Автозавершення транзакцій
 
-У наведеному вище прикладі ми запустили транзакцію та зробили запит на додавання. Але, як ми зазначали раніше, транзакція може мати кілька пов’язаних запитів, усі вони повинні бути успішними або невдалими. Як позначити транзакцію як завершену, без запитів?
+У наведеному вище прикладі ми запустили транзакцію та зробили запит на додавання. Але, як ми зазначали раніше, транзакція може мати кілька пов'язаних запитів, усі вони повинні бути успішними або невдалими. Як позначити транзакцію як завершену, без запитів?
 
 Коротка відповідь: це не потрібно.
 
@@ -372,7 +372,7 @@ request1.onsuccess = function() {
 
 Автори специфікації IndexedDB вважають, що транзакції мають бути короткочасними. В основному з міркувань продуктивності.
 
-Примітно, що транзакції `readwrite` "блокують" сховища для запису. Отже, якщо одна частина програми ініціювала `readwrite` у сховищі об’єктів `books`, тоді інша частина, яка хоче зробити те ж саме, повинна почекати: нова транзакція "зависає", доки не буде виконана перша. Це може призвести до дивних затримок, якщо транзакції займають багато часу.
+Примітно, що транзакції `readwrite` "блокують" сховища для запису. Отже, якщо одна частина програми ініціювала `readwrite` у сховищі об'єктів `books`, тоді інша частина, яка хоче зробити те ж саме, повинна почекати: нова транзакція "зависає", доки не буде виконана перша. Це може призвести до дивних затримок, якщо транзакції займають багато часу.
 
 Отже, що робити?
 
@@ -409,7 +409,7 @@ transaction.abort();
 
 Запити на запис можуть не виконуватися.
 
-Цього можна очікувати не лише через можливі помилки з нашого боку, а й з причин, не пов’язаних із самою транзакцією. Наприклад, закінчилося пам’ять. Тож ми повинні бути готові впоратися з такою справою.
+Цього можна очікувати не лише через можливі помилки з нашого боку, а й з причин, не пов'язаних із самою транзакцією. Наприклад, закінчилося пам'ять. Тож ми повинні бути готові впоратися з такою справою.
 
 **Невдалий запит автоматично перериває транзакцію, скасовуючи всі зміни.**
 
@@ -425,7 +425,7 @@ let book = { id: 'js', price: 10 };
 let request = transaction.objectStore("books").add(book);
 
 request.onerror = function(event) {
-  // ConstraintError виникає, коли об’єкт з таким же ідентифікатором вже існує
+  // ConstraintError виникає, коли об'єкт з таким же ідентифікатором вже існує
   if (request.error.name == "ConstraintError") {
     console.log("Книга з таким ідентифікатором вже існує"); // обробіть помилку
     event.preventDefault(); // запобігаємо скасуванню транзакції
@@ -479,18 +479,18 @@ request.onerror = function(event) {
 
 ## Пошук
 
-Існує два основних типи пошуку в сховищі об’єктів:
+Існує два основних типи пошуку в сховищі об'єктів:
 
 1. За значенням ключа або діапазоном ключа. У нашому сховищі «книги» це буде значення або діапазон значень `book.id`.
-2. За іншим полем об’єкта, напр. `book.price`. Для цього потрібна додаткова структура даних під назвою «index».
+2. За іншим полем об'єкта, напр. `book.price`. Для цього потрібна додаткова структура даних під назвою «index».
 
 ### За ключем
 
 Спочатку розберемося з першим типом пошуку: за ключем.
 
-Методи пошуку підтримують як точні значення ключів, та так звані "діапазони значень" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) об’єкти, які визначають прийнятний "діапазон ключів".
+Методи пошуку підтримують як точні значення ключів, та так звані "діапазони значень" -- [IDBKeyRange](https://www.w3.org/TR/IndexedDB/#keyrange) об'єкти, які визначають прийнятний "діапазон ключів".
 
-Об’єкти `IDBKeyRange` створюються за допомогою наступних викликів:
+Об'єкти `IDBKeyRange` створюються за допомогою наступних викликів:
 
 - `IDBKeyRange.lowerBound(lower, [open])` означає: `≥lower` (чи `>lower` якщо `open` є істина)
 - `IDBKeyRange.upperBound(upper, [open])` означає: `≤upper` (чи `<upper` якщо `open` є істина)
@@ -507,7 +507,7 @@ request.onerror = function(event) {
 - `store.getAllKeys([query], [count])` -- пошук усіх ключів, які задовольняють запиту, зазвичай діапазону, до `count`, якщо вказано.
 - `store.count([query])` -- отримати загальну кількість ключів, які задовольняють запиту, зазвичай діапазон.
 
-Наприклад, у нас в магазині багато книг. Пам’ятайте, що поле `id` є ключем, тому всі ці методи можуть здійснювати пошук за `id`.
+Наприклад, у нас в магазині багато книг. Пам'ятайте, що поле `id` є ключем, тому всі ці методи можуть здійснювати пошук за `id`.
 
 Приклади запитів:
 
@@ -528,17 +528,17 @@ books.getAll()
 books.getAllKeys(IDBKeyRange.lowerBound('js', true))
 ```
 
-```smart header="Сховище об’єктів завжди відсортовано"
-Сховище об’єктів внутрішньо сортує значення за ключем.
+```smart header="Сховище об'єктів завжди відсортовано"
+Сховище об'єктів внутрішньо сортує значення за ключем.
 
 Тому запити, які повертають багато значень, завжди повертають їх у відсортованому за ключем порядку.
 ```
 
 ### За полем за допомогою індексу
 
-Для пошуку за іншими полями об’єкта нам потрібно створити додаткову структуру даних під назвою «індекс».
+Для пошуку за іншими полями об'єкта нам потрібно створити додаткову структуру даних під назвою «індекс».
 
-Індекс — це «доповнення» до сховища, яке відстежує дане поле об’єкта. Для кожного значення цього поля він зберігає список ключів для об’єктів, які мають це значення. Нижче буде більш детальна картинка.
+Індекс — це «доповнення» до сховища, яке відстежує дане поле об'єкта. Для кожного значення цього поля він зберігає список ключів для об'єктів, які мають це значення. Нижче буде більш детальна картинка.
 
 Синтаксис:
 
@@ -546,17 +546,17 @@ books.getAllKeys(IDBKeyRange.lowerBound('js', true))
 objectStore.createIndex(name, keyPath, [options]);
 ```
 
-- **`name`** -- ім’я індексу,
-- **`keyPath`** -- шлях до поля об’єкта, яке має відстежувати індекс (ми будемо шукати за цим полем),
-- **`option`** -- необов’язковий об’єкт з властивостями:
-  - **`unique`** -- якщо значення true, то в сховищі може бути лише один об’єкт із заданим значенням у `keyPath`. Індекс забезпечить це, генеруючи помилку, якщо ми спробуємо додати дублікат.
-  - **`multiEntry`** -- використовується лише якщо значення `keyPath` є масивом. У цьому випадку індекс розглядатиме весь масив як ключ. Але якщо `multiEntry` має значення true, то індекс зберігатиме список об’єктів сховища для кожного значення в цьому масиві. Таким чином, члени масиву стають ключами індексу.
+- **`name`** -- ім'я індексу,
+- **`keyPath`** -- шлях до поля об'єкта, яке має відстежувати індекс (ми будемо шукати за цим полем),
+- **`option`** -- необов'язковий об'єкт з властивостями:
+  - **`unique`** -- якщо значення true, то в сховищі може бути лише один об'єкт із заданим значенням у `keyPath`. Індекс забезпечить це, генеруючи помилку, якщо ми спробуємо додати дублікат.
+  - **`multiEntry`** -- використовується лише якщо значення `keyPath` є масивом. У цьому випадку індекс розглядатиме весь масив як ключ. Але якщо `multiEntry` має значення true, то індекс зберігатиме список об'єктів сховища для кожного значення в цьому масиві. Таким чином, члени масиву стають ключами індексу.
 
 У нашому прикладі ми зберігаємо книги з ключем `id`.
 
 Скажімо, ми хочемо шукати за `price`.
 
-Спочатку нам потрібно створити індекс. Це потрібно зробити в `upgradeneeded`, як у сховищі об’єктів:
+Спочатку нам потрібно створити індекс. Це потрібно зробити в `upgradeneeded`, як у сховищі об'єктів:
 
 ```js
 openRequest.onupgradeneeded = function() {
@@ -607,7 +607,7 @@ request.onsuccess = function() {
 let request = priceIndex.getAll(IDBKeyRange.upperBound(5));
 ```
 
-Індекси внутрішньо відсортовані за полем відстежуваного об’єкта, у нашому випадку `price`. Тому, коли ми виконуємо пошук, результати також сортуються за `price`.
+Індекси внутрішньо відсортовані за полем відстежуваного об'єкта, у нашому випадку `price`. Тому, коли ми виконуємо пошук, результати також сортуються за `price`.
 
 ## Видалення зі сховища
 
@@ -622,7 +622,7 @@ let request = priceIndex.getAll(IDBKeyRange.upperBound(5));
 books.delete('js');
 ```
 
-Якщо ми хочемо видалити книги на основі ціни або іншого поля об’єкта, то спочатку ми повинні знайти ключ в індексі, а потім викликати `delete`:
+Якщо ми хочемо видалити книги на основі ціни або іншого поля об'єкта, то спочатку ми повинні знайти ключ в індексі, а потім викликати `delete`:
 
 ```js
 // знайти ключ з price = 5
@@ -644,15 +644,15 @@ books.clear(); // очистити сховище.
 
 Такі методи, як `getAll/getAllKeys` повертають масив ключів/значень.
 
-Але сховище об’єктів може бути величезним, більшим за доступну пам’ять. Тоді `getAll` не зможе отримати всі записи у вигляді масиву.
+Але сховище об'єктів може бути величезним, більшим за доступну пам'ять. Тоді `getAll` не зможе отримати всі записи у вигляді масиву.
 
 Що робити?
 
 Курсори забезпечують засоби, щоб обійти це.
 
-**Об’єкт *cursor* — це спеціальний об’єкт, який обходить сховище об’єктів за запитом і повертає один ключ/значення за раз, економлячи таким чином пам’ять.**
+**Об'єкт *cursor* — це спеціальний об'єкт, який обходить сховище об'єктів за запитом і повертає один ключ/значення за раз, економлячи таким чином пам'ять.**
 
-Оскільки сховище об’єктів внутрішньо відсортовано за ключем, курсор проходить по сховищу в порядку знаходження ключа (типово за зростанням).
+Оскільки сховище об'єктів внутрішньо відсортовано за ключем, курсор проходить по сховищу в порядку знаходження ключа (типово за зростанням).
 
 Синтаксис:
 
@@ -664,7 +664,7 @@ let request = store.openCursor(query, [direction]);
 ```
 
 - **`query`** є ключем або діапазоном ключів, як і для `getAll`.
-- **`direction`** є необов’язковим аргументом, що вказує який порядок використовувати:
+- **`direction`** є необов'язковим аргументом, що вказує який порядок використовувати:
  - `"next"` -- типово, курсор піднімається від найнижчого ключа до найвищчого.
  - `"prev"` -- зворотний порядок: вниз від запису з найбільшим ключем.
  - `"nextunique"`, `"prevunique"` -- те саме, що й вище, але пропускає записи з тим же ключем, який вже був (лише для курсорів за індексами, наприклад, для кількох книг із ціною=5 буде повернута лише перша).
@@ -684,7 +684,7 @@ request.onsuccess = function() {
   let cursor = request.result;
   if (cursor) {
     let key = cursor.key; // ключ книги (поле id)
-    let value = cursor.value; // книжковий об’єкт
+    let value = cursor.value; // книжковий об'єкт
     console.log(key, value);
     cursor.continue();
   } else {
@@ -700,11 +700,11 @@ request.onsuccess = function() {
 
 Незалежно від того, чи є значення, що відповідають курсору, чи ні – викликається `onsuccess`, а потім у `result` ми можемо отримати курсор, що вказує на наступний запис, або `undefined`.
 
-У наведеному вище прикладі курсор був створений для сховища об’єктів.
+У наведеному вище прикладі курсор був створений для сховища об'єктів.
 
-Але ми також можемо навести курсор на індекс. Як ми пам’ятаємо, індекси дозволяють здійснювати пошук по полю об’єкта. Курсори над індексами діють точно так само, як і над сховищами об’єктів — вони економлять пам’ять, повертаючи по одному значенню за раз.
+Але ми також можемо навести курсор на індекс. Як ми пам'ятаємо, індекси дозволяють здійснювати пошук по полю об'єкта. Курсори над індексами діють точно так само, як і над сховищами об'єктів — вони економлять пам'ять, повертаючи по одному значенню за раз.
 
-Для курсорів над індексами `cursor.key` є ключем індексу (наприклад, ціна), і ми повинні використовувати властивість `cursor.primaryKey` для ключа об’єкта:
+Для курсорів над індексами `cursor.key` є ключем індексу (наприклад, ціна), і ми повинні використовувати властивість `cursor.primaryKey` для ключа об'єкта:
 
 ```js
 let request = priceIdx.openCursor(IDBKeyRange.upperBound(5));
@@ -713,8 +713,8 @@ let request = priceIdx.openCursor(IDBKeyRange.upperBound(5));
 request.onsuccess = function() {
   let cursor = request.result;
   if (cursor) {
-    let primaryKey = cursor.primaryKey; // ключ сховища наступного об’єкта (поле id)
-    let value = cursor.value; // наступний об’єкт сховища (об’єкт книги)
+    let primaryKey = cursor.primaryKey; // ключ сховища наступного об'єкта (поле id)
+    let value = cursor.value; // наступний об'єкт сховища (об'єкт книги)
     let key = cursor.key; // наступний ключ індексу (price)
     console.log(key, value);
     cursor.continue();
@@ -728,7 +728,7 @@ request.onsuccess = function() {
 
 Додавання `onsuccess/onerror` до кожного запиту є досить громіздким завданням. Іноді ми можемо полегшити життя, використовуючи делегування подій, напр. встановити обробники для всіх транзакцій, але `async/await` набагато зручніше. 
 
-Давайте використаємо тонку обгортку промісів <https://github.com/jakearchibald/idb> далі в цьому розділі. Вона створює глобальний об’єкт `idb` з методами IndexedDB [promisified](info:promisify).
+Давайте використаємо тонку обгортку промісів <https://github.com/jakearchibald/idb> далі в цьому розділі. Вона створює глобальний об'єкт `idb` з методами IndexedDB [promisified](info:promisify).
 
 Тоді замість `onsuccess/onerror` ми можемо написати так:
 
@@ -761,14 +761,14 @@ try {
 
 Якщо ми не ловимо помилку, вона провалюється до найближчого зовнішнього `try..catch`.
 
-Невиявлена помилка стає подією "необробленого відхилення промісу" на об’єкті `window`.
+Невиявлена помилка стає подією "необробленого відхилення промісу" на об'єкті `window`.
 
 Ми можемо обробляти такі помилки таким чином:
 
 ```js
 window.addEventListener('unhandledrejection', event => {
-  let request = event.target; // Власний об’єкт запиту IndexedDB
-  let error = event.reason; //  Необроблений об’єкт помилки, те саме, що request.error
+  let request = event.target; // Власний об'єкт запиту IndexedDB
+  let error = event.reason; //  Необроблений об'єкт помилки, те саме, що request.error
   ...повідомити про помилку...
 });
 ```
@@ -799,19 +799,19 @@ await inventory.add({ id: 'js', price: 10, created: new Date() }); // Помил
 1. Підготуйте дані та спершу отримайте все необхідне.
 2. Потім збережіть у базі даних.
 
-### Отримання вбудованих об’єктів
+### Отримання вбудованих об'єктів
 
-Внутрішньо обгортка виконує запит IndexedDB, додаючи до нього `onerror/onsuccess`, і повертає проміс, який відхиляється/розв’язується з результатом.
+Внутрішньо обгортка виконує запит IndexedDB, додаючи до нього `onerror/onsuccess`, і повертає проміс, який відхиляється/розв'язується з результатом.
 
 Це добре працює більшість часу. Приклади є на сторінці lib <https://github.com/jakearchibald/idb>.
 
-У кількох рідкісних випадках, коли нам потрібен оригінальний об’єкт `request`, ми можемо отримати до нього доступ як властивості `promise.request` промісу:
+У кількох рідкісних випадках, коли нам потрібен оригінальний об'єкт `request`, ми можемо отримати до нього доступ як властивості `promise.request` промісу:
 
 ```js
 let promise = books.add(book); // отримати проміс (не чекаємо результату)
 
-let request = promise.request; // вбудований об’єкт запиту
-let transaction = request.transaction; // вбудований об’єкт транзакції
+let request = promise.request; // вбудований об'єкт запиту
+let transaction = request.transaction; // вбудований об'єкт транзакції
 
 // ...працюємо з IndexedDB...
 
@@ -828,13 +828,13 @@ IndexedDB можна розглядати як «локальне сховище
 
 1. Підключити обгортку над промісами, наприклад [idb](https://github.com/jakearchibald/idb).
 2. Відкрити базу даних: `idb.openDb(name, version, onupgradeneeded)`
-    - Створити сховища об’єктів та індекси в обробнику `onupgradeneeded` або виконати оновлення версії, якщо потрібно.
+    - Створити сховища об'єктів та індекси в обробнику `onupgradeneeded` або виконати оновлення версії, якщо потрібно.
 3. Для запитів:
     - Створити транзакцію `db.transaction('books')` (можна вказати readwrite якщо потрібно).
-    - Отримати сховище об’єктів `transaction.objectStore('books')`.
-4. Потім для пошуку за ключем викликати методи безпосередньо в сховищі об’єктів.
-    - Для пошуку по полю об’єкта потрібно створити індекс.
-5. Використовувати курсор, якщо дані не поміщаються в пам’ять.
+    - Отримати сховище об'єктів `transaction.objectStore('books')`.
+4. Потім для пошуку за ключем викликати методи безпосередньо в сховищі об'єктів.
+    - Для пошуку по полю об'єкта потрібно створити індекс.
+5. Використовувати курсор, якщо дані не поміщаються в пам'ять.
 
 Ось невелика демонстраційна програма:
 

From 8babf92aa5eb3ca99ac36c1d5e810435e0351059 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:27 +0300
Subject: [PATCH 07/11] =?UTF-8?q?feat(7-animation):=20Changed=20all=20apos?=
 =?UTF-8?q?trophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 7-animation/1-bezier-curve/article.md                | 12 ++++++------
 .../4-animate-circle-callback/task.md                |  2 +-
 7-animation/2-css-animations/article.md              | 10 +++++-----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/7-animation/1-bezier-curve/article.md b/7-animation/1-bezier-curve/article.md
index 42eed1462..6d294cec2 100644
--- a/7-animation/1-bezier-curve/article.md
+++ b/7-animation/1-bezier-curve/article.md
@@ -1,6 +1,6 @@
 # Крива Безьє
 
-Криві Безьє використовують у комп’ютерній графіці для малювання гладких фігур, для CSS-анімації та у багатьох інших випадках.
+Криві Безьє використовують у комп'ютерній графіці для малювання гладких фігур, для CSS-анімації та у багатьох інших випадках.
 
 Це дуже проста річ, яку варто дослідити один раз, щоб надалі комфортно почуватись у світі векторної графіки та просунутих анімацій.
 
@@ -37,7 +37,7 @@
 
     ![](bezier4-e.svg) ![](bezier3-e.svg)
 
-Остання властивість дозволяє оптимізувати пошук перетинів у комп’ютерній графіці. Криві не перетинаються, якщо їх опуклі оболонки не перетинаються. Тож попередня перевірка на перетин опуклих оболонок може вказати на відсутність перетину. Перевірка перетину опуклих оболонок значно легша, оскільки вони мають форму чотирикутника, трикутника тощо (дивіться малюнок вище), значно простіші фігури, ніж сама крива.
+Остання властивість дозволяє оптимізувати пошук перетинів у комп'ютерній графіці. Криві не перетинаються, якщо їх опуклі оболонки не перетинаються. Тож попередня перевірка на перетин опуклих оболонок може вказати на відсутність перетину. Перевірка перетину опуклих оболонок значно легша, оскільки вони мають форму чотирикутника, трикутника тощо (дивіться малюнок вище), значно простіші фігури, ніж сама крива.
 
 **Головна цінність кривих Безьє для малювання в тому, що пересування контрольних точок змінює криву *інтуїтивно зрозумілим чином*.**
 
@@ -78,7 +78,7 @@
 
         Наприклад, для `t=0` -- обидві точки будуть на початку відрізка, для `t=0.25` -- на відстані 25% довжини відрізка від початку, для `t=0.5` -- 50% (на середині), для `t=1` -- в кінці відрізка.
 
-    - З’єднаймо ці точки. На зображенні нижче цей відрізок має <span style="color:#167490">синій</span> колір.
+    - З'єднаймо ці точки. На зображенні нижче цей відрізок має <span style="color:#167490">синій</span> колір.
 
 
 | Для `t=0.25`             | Для `t=0.5`            |
@@ -99,7 +99,7 @@
 
 - Поєднаймо контрольні точки відрізками: 1 -> 2, 2 -> 3, 3 -> 4. Отримаємо 3 <span style="color:#825E28">коричневі</span> відрізки.
 - Для кожного `t` у інтервалі від `0` до `1`:
-    - Ми беремо точки на цих відрізках на відстані від початку пропорційній до `t`. З’єднаємо ці точки, що дає нам два <span style="color:#0A0">зелених відрізки</span>.
+    - Ми беремо точки на цих відрізках на відстані від початку пропорційній до `t`. З'єднаємо ці точки, що дає нам два <span style="color:#0A0">зелених відрізки</span>.
     - На цих відрізках ми беремо точки, що пропорційні до `t`. Отримуємо <span style="color:#167490">синій відрізок</span>.
     - На синьому відрізку беремо точку, що пропорційна до `t`. У попередньому прикладі вона <span style="color:red">червоного</span> кольору.
 - Разом ці точки утворюють криву.
@@ -147,7 +147,7 @@
 
 Інколи ми маємо інше завдання: намалювати криву, що *проходить крізь декілька точок*, тобто всі точки знаходяться на одній гладкій кривій. Ця задача називається [інтерполяцією](https://uk.wikipedia.org/wiki/Інтерполяція), і тут ми не будемо її розглядати.
 
-Для таких кривих існують математичні формули, наприклад [многочлен Лагранжа](https://uk.wikipedia.org/wiki/Многочлен_Лагранжа). У комп’ютерній графіці для побудови гладких кривих, які поєднують багато точок, використовується [інтерполяція кубічними сплайнами](https://uk.wikipedia.org/wiki/Кубічний_сплайн).
+Для таких кривих існують математичні формули, наприклад [многочлен Лагранжа](https://uk.wikipedia.org/wiki/Многочлен_Лагранжа). У комп'ютерній графіці для побудови гладких кривих, які поєднують багато точок, використовується [інтерполяція кубічними сплайнами](https://uk.wikipedia.org/wiki/Кубічний_сплайн).
 ```
 
 
@@ -202,6 +202,6 @@
 
 Використання:
 
-- У комп’ютерній графіці, моделюванні, редакторах векторної графіки. Шрифти також описані кривими Безьє.
+- У комп'ютерній графіці, моделюванні, редакторах векторної графіки. Шрифти також описані кривими Безьє.
 - У веб-розробці -- для графіки на Canvas, або у форматі SVG. До речі, всі "живі" приклади наведені вище написані на SVG. Насправді це один і той самий SVG-документ, якому точки передані як параметри. Ви можете відкрити його у окремому вікні та переглянути його вихідний код: [demo.svg](demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1).
 - У CSS-анімації, щоб описати траєкторію або швидкість анімації.
diff --git a/7-animation/2-css-animations/4-animate-circle-callback/task.md b/7-animation/2-css-animations/4-animate-circle-callback/task.md
index cacf19d36..d1b081724 100644
--- a/7-animation/2-css-animations/4-animate-circle-callback/task.md
+++ b/7-animation/2-css-animations/4-animate-circle-callback/task.md
@@ -3,7 +3,7 @@
 
 У завданні <info:task/animate-circle> показана анімація зростання кола.
 
-Припустимо, що нам потрібно показати повідомлення всередині нього. Повідомлення має з’явитися *після* завершення анімації (коли коло повністю виросло), інакше це виглядатиме погано.
+Припустимо, що нам потрібно показати повідомлення всередині нього. Повідомлення має з'явитися *після* завершення анімації (коли коло повністю виросло), інакше це виглядатиме погано.
 
 У вирішенні завдання функція `showCircle(cx, cy, radius)` малює коло, але не дає можливості відстежити, коли воно готове.
 
diff --git a/7-animation/2-css-animations/article.md b/7-animation/2-css-animations/article.md
index 9cf63ba2e..fba7fc878 100644
--- a/7-animation/2-css-animations/article.md
+++ b/7-animation/2-css-animations/article.md
@@ -143,7 +143,7 @@ stripe.onclick = function() {
 2. Остання контрольна точка: `(1,1)`.
 3. Для проміжних точок значення `x` мають бути в інтервалі `0..1`, `y` може бути будь-яким.
 
-Синтаксис кривої Без’є в CSS: `cubic-bezier(x2, y2, x3, y3)`. Тут нам потрібно вказати лише 2-гу і 3-тю контрольні точки, тому що 1-ша фіксована на `(0,0)`, а 4-та -- `(1,1)`.
+Синтаксис кривої Без'є в CSS: `cubic-bezier(x2, y2, x3, y3)`. Тут нам потрібно вказати лише 2-гу і 3-тю контрольні точки, тому що 1-ша фіксована на `(0,0)`, а 4-та -- `(1,1)`.
 
 Функція часу описує, швидкість процесу анімації.
 
@@ -378,7 +378,7 @@ boat.onclick = function() {
 };
 ```
 
-Об’єкт події для `transitionend` має кілька специфічних властивостей:
+Об'єкт події для `transitionend` має кілька специфічних властивостей:
 
 `event.propertyName`
 : Властивість, яка завершила анімацію. Може бути корисна коли ми анімуємо кілька властивостей одночасно.
@@ -388,9 +388,9 @@ boat.onclick = function() {
 
 ## Keyframes
 
-Ми можемо об’єднати кілька простих анімацій разом за допомогою правила CSS `@keyframes`.
+Ми можемо об'єднати кілька простих анімацій разом за допомогою правила CSS `@keyframes`.
 
-Воно визначає "ім’я" анімації та правила - що, коли і де анімувати. Використовуючи властивість `animation`, ми можемо приєднати анімацію до елемента та вказати додаткові параметри.
+Воно визначає "ім'я" анімації та правила - що, коли і де анімувати. Використовуючи властивість `animation`, ми можемо приєднати анімацію до елемента та вказати додаткові параметри.
 
 Ось приклад із поясненнями:
 
@@ -399,7 +399,7 @@ boat.onclick = function() {
 
 <style>
 *!*
-  @keyframes go-left-right {        /* ім’я анімації: "go-left-right" */
+  @keyframes go-left-right {        /* ім'я анімації: "go-left-right" */
     from { left: 0px; }             /* початок анімації від left: 0px */
     to { left: calc(100% - 50px); } /* кінець анімації до left: 100%-50px */
   }

From 03c514c06db421b47441b2791d31a8b8f12e0d86 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:27 +0300
Subject: [PATCH 08/11] =?UTF-8?q?feat(8-web-components):=20Changed=20all?=
 =?UTF-8?q?=20apostrophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 8-web-components/1-webcomponents-intro/article.md |  2 +-
 8-web-components/4-template-element/article.md    |  2 +-
 8-web-components/5-slots-composition/article.md   | 14 +++++++-------
 8-web-components/6-shadow-dom-style/article.md    |  4 ++--
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/8-web-components/1-webcomponents-intro/article.md b/8-web-components/1-webcomponents-intro/article.md
index 0cad28722..c66245cd3 100644
--- a/8-web-components/1-webcomponents-intro/article.md
+++ b/8-web-components/1-webcomponents-intro/article.md
@@ -2,7 +2,7 @@
 
 Ця секція описує набір сучасних стандартів для "веб компонентів".
 
-Наразі, ці стандарти знаходяться в розробці. Деякі особливості зараз добре підтримуються та інтегровані у сучасний HTML/DOM стандарт, але деякі все ще у стадії чернетки. Ви можете погратись з прикладами у будь-якому браузері, але Google Chrome, мабуть, має найкращу підтримку. Скоріш за все це пов’язано з тим, що саме компанія Google стоїть за багатьма специфікаціями до веб компонентів.
+Наразі, ці стандарти знаходяться в розробці. Деякі особливості зараз добре підтримуються та інтегровані у сучасний HTML/DOM стандарт, але деякі все ще у стадії чернетки. Ви можете погратись з прикладами у будь-якому браузері, але Google Chrome, мабуть, має найкращу підтримку. Скоріш за все це пов'язано з тим, що саме компанія Google стоїть за багатьма специфікаціями до веб компонентів.
 
 ## Що спільного між...
 
diff --git a/8-web-components/4-template-element/article.md b/8-web-components/4-template-element/article.md
index b5625367d..0ae2f8484 100644
--- a/8-web-components/4-template-element/article.md
+++ b/8-web-components/4-template-element/article.md
@@ -113,4 +113,4 @@
 - ...Але все одно дозволяє використання будь-якого тега HTML, навіть тих, використання яких не має сенсу без відповідної обгортки (напр. `<tr>`).
 - Вміст стає інтерактивним: виконуються скрипти, запускається `<video autoplay>` і т. ін., коли ми переміщаємо його у документ.
 
-Елемент `<template>` не має жодних механізмів ітерації, зв’язування даних чи заміни змінних, але ми можемо реалізувати їх поверх нього.
+Елемент `<template>` не має жодних механізмів ітерації, зв'язування даних чи заміни змінних, але ми можемо реалізувати їх поверх нього.
diff --git a/8-web-components/5-slots-composition/article.md b/8-web-components/5-slots-composition/article.md
index e40450969..1d1a9f9d2 100644
--- a/8-web-components/5-slots-composition/article.md
+++ b/8-web-components/5-slots-composition/article.md
@@ -35,7 +35,7 @@ customElements.define('user-card', class extends HTMLElement {
   connectedCallback() {
     this.attachShadow({mode: 'open'});
     this.shadowRoot.innerHTML = `
-      <div>Ім’я:
+      <div>Ім'я:
 *!*
         <slot name="username"></slot>
 */!*
@@ -65,7 +65,7 @@ customElements.define('user-card', class extends HTMLElement {
 ```html
 <user-card>
   #shadow-root
-    <div>Ім’я:
+    <div>Ім'я:
       <slot name="username"></slot>
     </div>
     <div>Дата народження:
@@ -143,7 +143,7 @@ alert( document.querySelectorAll('user-card span').length ); // 2
 ```html
 <user-card>
   #shadow-root
-    <div>Ім’я:
+    <div>Ім'я:
       <slot name="username">
         <span slot="username">Тарас</span>
         <span slot="username">Мельник</span>
@@ -162,7 +162,7 @@ alert( document.querySelectorAll('user-card span').length ); // 2
 Наприклад, у цьому шматку shadow DOM, буде відображено `Анонім`, якщо у світлому DOM немає `slot="username"`.
 
 ```html
-<div>Ім’я:
+<div>Ім'я:
   <slot name="username">Анонім</slot>
 </div>
 ```
@@ -179,7 +179,7 @@ customElements.define('user-card', class extends HTMLElement {
   connectedCallback() {
     this.attachShadow({mode: 'open'});
     this.shadowRoot.innerHTML = `
-    <div>Ім’я:
+    <div>Ім'я:
       <slot name="username"></slot>
     </div>
     <div>День народження:
@@ -217,7 +217,7 @@ customElements.define('user-card', class extends HTMLElement {
 ```html
 <user-card>
   #shadow-root
-    <div>Ім’я:
+    <div>Ім'я:
       <slot name="username">
         <span slot="username">Тарас Мельник</span>
       </slot>
@@ -379,7 +379,7 @@ setTimeout(() => {
 
 ## API слотів
 
-Зрештою, давайте зачепимо методи JavaScript, що пов’язані зі слотами.
+Зрештою, давайте зачепимо методи JavaScript, що пов'язані зі слотами.
 
 Як ми вже бачили, JavaScript дивиться на "справжній" DOM, без розгортання. Але якщо тіньове дерево має `{mode: 'open'}`, тоді ми можемо визначити які елементи призначені до слота і навпаки, знайти слот за елементом всередині нього:
 
diff --git a/8-web-components/6-shadow-dom-style/article.md b/8-web-components/6-shadow-dom-style/article.md
index 8c647cc2e..e9936ddb7 100644
--- a/8-web-components/6-shadow-dom-style/article.md
+++ b/8-web-components/6-shadow-dom-style/article.md
@@ -242,7 +242,7 @@ customElements.define('user-card', class extends HTMLElement {
     /* якщо --user-card-field-color не призначено, використовуємо чорний колір */
   }
 </style>
-<div class="field">Ім’я: <slot name="username"></slot></div>
+<div class="field">Ім'я: <slot name="username"></slot></div>
 <div class="field">День народження: <slot name="birthday"></slot></div>
 ```
 
@@ -275,7 +275,7 @@ user-card {
     }
 */!*
   </style>
-  <div class="field">Ім’я: <slot name="username"></slot></div>
+  <div class="field">Ім'я: <slot name="username"></slot></div>
   <div class="field">День народження: <slot name="birthday"></slot></div>
 </template>
 

From d9195747a0dd239b8b158663502fab8819e08476 Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:28 +0300
Subject: [PATCH 09/11] =?UTF-8?q?feat(9-regular-expressions):=20Changed=20?=
 =?UTF-8?q?all=20apostrophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../01-regexp-introduction/article.md         |  8 ++---
 .../07-regexp-escaping/article.md             |  2 +-
 .../10-regexp-greedy-and-lazy/article.md      |  2 +-
 .../03-find-decimal-numbers/solution.md       |  4 +--
 .../03-find-decimal-numbers/task.md           |  2 +-
 .../04-parse-expression/solution.md           |  2 +-
 .../11-regexp-groups/article.md               | 30 +++++++++----------
 .../12-regexp-backreferences/article.md       |  2 +-
 .../01-find-programming-language/solution.md  |  2 +-
 .../03-match-quoted-string/task.md            |  2 +-
 .../13-regexp-alternation/article.md          |  2 +-
 .../article.md                                | 18 +++++------
 .../17-regexp-methods/article.md              | 14 ++++-----
 13 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 79a1317a5..1dbd593df 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -2,11 +2,11 @@
 
 Регулярні вирази – потужний засіб пошуку та заміни тексту в рядках.
 
-В JavaScript регулярні вирази реалізовані окремим об’єктом [RegExp](mdn:js/RegExp) та інтегровані у методи рядків.
+В JavaScript регулярні вирази реалізовані окремим об'єктом [RegExp](mdn:js/RegExp) та інтегровані у методи рядків.
 
 ## Регулярні вирази
 
-Регулярний вираз (він же "регексп", "регулярка" або просто "рег"), складається з *шаблону* (також кажуть "патерн") і необов’язкових *прапорів*.
+Регулярний вираз (він же "регексп", "регулярка" або просто "рег"), складається з *шаблону* (також кажуть "патерн") і необов'язкових *прапорів*.
 
 Існує два синтаксиси для створення регулярного виразу.
 
@@ -25,7 +25,7 @@ regexp = /шаблон/gmi; // з прапорами g,m та i (будуть о
 
 Слеши `pattern:/.../` говорять JavaScript про те, що це регулярний вираз. Вони відіграють таку саму роль, як і лапки для позначення рядків.
 
-Регулярний вираз `regexp` в обох випадках є об’єктом вбудованого класу `RegExp`.
+Регулярний вираз `regexp` в обох випадках є об'єктом вбудованого класу `RegExp`.
 
 Основна різниця між цими двома синтаксами полягає в тому, що слеши `/.../` не допускають жодних вставок змінних (на зразок тих, що прописуються через `${...}`). Вони повністю статичні.
 
@@ -167,7 +167,7 @@ alert( regexp.test(str) ); // true
 
 ## Підсумки
 
-- Регулярний вираз складається з шаблону і необов’язкових прапорів: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
+- Регулярний вираз складається з шаблону і необов'язкових прапорів: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
 - Без прапорів та спеціальних символів, які ми вивчимо пізніше, пошук за регулярним виразом аналогічний пошуку підрядка.
 - Метод `str.match(regexp)` шукає збіги: всі, якщо є прапор `pattern:g`, інакше тільки перший.
 - Метод `str.replace(regexp, replacement)` замінює збіги з `regexp` на `replacement`: всі, якщо у регулярного виразу є прапор `pattern:g`, інакше тільки перший.
diff --git a/9-regular-expressions/07-regexp-escaping/article.md b/9-regular-expressions/07-regexp-escaping/article.md
index c8a5cd96c..be9d9b559 100644
--- a/9-regular-expressions/07-regexp-escaping/article.md
+++ b/9-regular-expressions/07-regexp-escaping/article.md
@@ -63,7 +63,7 @@ alert( "Chapter 5.1".match(regexp) ); // null
 
 Подібний пошук в одному з попередніх прикладів працював із `pattern:/\d\.\d/`, але `new RegExp("\d\.\d")` не працює, чому?
 
-Причина полягає в тому, що рядок "поглинає" бекслеши. Як ми можемо пам’ятати, звичайні рядки мають власні спеціальні символи, такі як `\n`, а бекслеш використовується для їх екранування.
+Причина полягає в тому, що рядок "поглинає" бекслеши. Як ми можемо пам'ятати, звичайні рядки мають власні спеціальні символи, такі як `\n`, а бекслеш використовується для їх екранування.
 
 Ось як сприймається "\d\.\d":
 
diff --git a/9-regular-expressions/10-regexp-greedy-and-lazy/article.md b/9-regular-expressions/10-regexp-greedy-and-lazy/article.md
index a8929c241..6eb20bda8 100644
--- a/9-regular-expressions/10-regexp-greedy-and-lazy/article.md
+++ b/9-regular-expressions/10-regexp-greedy-and-lazy/article.md
@@ -163,7 +163,7 @@ alert( "123 456".match(/\d+ \d+?/) ); // 123 4
 ```smart header="Optimizations"
 Сучасні рушії регулярних виразів можуть оптимізовувати внутрішні алгоритми задля швидшої роботи. Тож їх алгоритм роботи може трішки відрізнятись від щойно описаного.
 
-Але, для розуміння принципу побудови та роботи регулярних виразів, нам все це знати не обов’язково. Вони використовуються виключно внутрішньо для оптимізації.
+Але, для розуміння принципу побудови та роботи регулярних виразів, нам все це знати не обов'язково. Вони використовуються виключно внутрішньо для оптимізації.
 
 Складні регулярні вирази погано піддаються оптимізації, тож пошук працюватиме саме так, як описано вище.
 ```
diff --git a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md
index 4abbbd407..112629f4e 100644
--- a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md
+++ b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/solution.md
@@ -1,6 +1,6 @@
-Додатне число з необов’язковою десятковою частиною: `pattern:\d+(\.\d+)?`.
+Додатне число з необов'язковою десятковою частиною: `pattern:\d+(\.\d+)?`.
 
-Додамо необов’язковий `pattern:-` на початку:
+Додамо необов'язковий `pattern:-` на початку:
 
 ```js run
 let regexp = /-?\d+(\.\d+)?/g;
diff --git a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md
index e5744ca44..be8fb91e6 100644
--- a/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md
+++ b/9-regular-expressions/11-regexp-groups/03-find-decimal-numbers/task.md
@@ -1,6 +1,6 @@
 # Знайти всі числа
 
-Напишіть регулярний вираз, який шукатиме всі десяткові числа, включно з числами цілими, з плаваючою комою та від’ємними.
+Напишіть регулярний вираз, який шукатиме всі десяткові числа, включно з числами цілими, з плаваючою комою та від'ємними.
 
 Приклад використання:
 
diff --git a/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md b/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md
index 01ae40e9b..c627aeaf2 100644
--- a/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md
+++ b/9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md
@@ -30,7 +30,7 @@ alert( "1.2 + 12".match(regexp) );
 - `result[2] == ".2"` (друга група `(\.\d+)?` -- перша десяткова частина)
 - `result[3] == "+"` (третя група `([-+*\/])` -- оператор)
 - `result[4] == "12"` (четверта група `(-?\d+(\.\d+)?)` -- друге число)
-- `result[5] == undefined` (п’ята група `(\.\d+)?` -- остання десяткова частина відсутня, тому вона undefined)
+- `result[5] == undefined` (п'ята група `(\.\d+)?` -- остання десяткова частина відсутня, тому вона undefined)
 
 Нам потрібні лише числа та оператор, без повного збігу чи десяткових частин, тож проведемо невелику "чистку" результату.
 
diff --git a/9-regular-expressions/11-regexp-groups/article.md b/9-regular-expressions/11-regexp-groups/article.md
index a870060cc..c02b4e2fd 100644
--- a/9-regular-expressions/11-regexp-groups/article.md
+++ b/9-regular-expressions/11-regexp-groups/article.md
@@ -15,7 +15,7 @@
 
 Без круглих дужок, вираз `pattern:go+` означає символ `subject:g`, за яким слідує `subject:o` на повторі один чи кілька разів. Тобто, `match:goooo` чи `match:gooooooooo`.
 
-Круглі дужки об’єднують символи в групи, тож `pattern:(go)+` означає `match:go`, `match:gogo`, `match:gogogo` і так далі.
+Круглі дужки об'єднують символи в групи, тож `pattern:(go)+` означає `match:go`, `match:gogo`, `match:gogogo` і так далі.
 
 ```js run
 alert( 'Gogogo now!'.match(/(go)+/ig) ); // "Gogogo"
@@ -123,15 +123,15 @@ alert(result[3]); // class="my"
 
 Далі йдуть групи, нумеровані зліва направо за відкриваючою дужкою. Перша група розміщена в `result[1]`. В даному випадку, вона охоплює весь вміст тегу.
 
-Далі, в `result[2]` отримуємо групу з других дужок `pattern:([a-z]+)` - ім’я тегу, в `result[3]` - тег `pattern:([^>]*)`.
+Далі, в `result[2]` отримуємо групу з других дужок `pattern:([a-z]+)` - ім'я тегу, в `result[3]` - тег `pattern:([^>]*)`.
 
 Вміст кожної групи в рядку:
 
 ![](regexp-nested-groups-matches.svg)
 
-### Необов’язкові групи
+### Необов'язкові групи
 
-Навіть якщо група необов’язкова та не існує всередині збігу (тобто має квантифікатор `pattern:(...)?`), відповідний елемент масиву `result` наявний та дорівнює `undefined`.
+Навіть якщо група необов'язкова та не існує всередині збігу (тобто має квантифікатор `pattern:(...)?`), відповідний елемент масиву `result` наявний та дорівнює `undefined`.
 
 Для прикладу, розглянемо регулярний вираз `pattern:a(z)?(c)?`. Він шукає `"a"`, після якої може йти `"z"`, після якої може йти `"c"`.
 
@@ -166,7 +166,7 @@ alert( match[2] ); // c
 ```warn header="`matchAll` є новим методом, може знадобитись поліфіл"
 Метод `matchAll` не підтримується старими браузерами.
 
-Поліфіл може бути обов’язковим, такий як <https://github.com/ljharb/String.prototype.matchAll>.
+Поліфіл може бути обов'язковим, такий як <https://github.com/ljharb/String.prototype.matchAll>.
 ```
 
 Коли ми шукаємо всі збіги (прапорець `pattern:g`), метод `match` не повертає вміст для груп.
@@ -189,16 +189,16 @@ alert( tags ); // <h1>,<h2>
 
 Як і `match`, метод шукає збіги, але з урахуванням 3-ьох відмінностей:
 
-1. Він повертає не масив, а ітерований об’єкт.
+1. Він повертає не масив, а ітерований об'єкт.
 2. За наявності прапорцю `pattern:g`, він повертає кожен збіг у вигляді масиву з групами.
-3. Якщо збігів немає, він повертає замість `null` порожній ітерований об’єкт.
+3. Якщо збігів немає, він повертає замість `null` порожній ітерований об'єкт.
 
 Наприклад:
 
 ```js run
 let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 
-// results - є не масивом, а ітерованим об’єктом
+// results - є не масивом, а ітерованим об'єктом
 alert(results); // [object RegExp String Iterator]
 
 alert(results[0]); // undefined (*)
@@ -209,7 +209,7 @@ alert(results[0]); // <h1>,h1 (перший тег)
 alert(results[1]); // <h2>,h2 (другий тег)
 ```
 
-Як можемо бачити, перша відмінність дуже важлива, як демонструється в рядку `(*)`. Ми не можемо отримати збіг у вигляді `results[0]`, бо цей об’єкт не є псевдомасивом. Ми можемо перетворити його на реальний `Array`, використовуючи `Array.from`. Детальніше про псевдомасиви та ітеровані об’єкти в статті <info:iterable>.
+Як можемо бачити, перша відмінність дуже важлива, як демонструється в рядку `(*)`. Ми не можемо отримати збіг у вигляді `results[0]`, бо цей об'єкт не є псевдомасивом. Ми можемо перетворити його на реальний `Array`, використовуючи `Array.from`. Детальніше про псевдомасиви та ітеровані об'єкти в статті <info:iterable>.
 
 Нема потреби в `Array.from`, якщо ми циклічно проходимось по результатам:
 
@@ -242,10 +242,10 @@ alert( tag1.index ); // 0
 alert( tag1.input ); // <h1> <h2>
 ```
 
-```smart header="Чому результатом `matchAll` є ітерований об’єкт, а не масив?"
+```smart header="Чому результатом `matchAll` є ітерований об'єкт, а не масив?"
 Чому цей метод так спроектовано? Причина проста - заради оптимізації.
 
-Виклик `matchAll` не проводить пошуку. Натомість, повертається ітерований об’єкт, спочатку без результатів. Пошук проводиться кожного разу ми проходимось об’єктом, наприклад, всередині циклу.
+Виклик `matchAll` не проводить пошуку. Натомість, повертається ітерований об'єкт, спочатку без результатів. Пошук проводиться кожного разу ми проходимось об'єктом, наприклад, всередині циклу.
 
 Тобто, буде знайдено потрібну кількість результатів, не більше.
 
@@ -254,7 +254,7 @@ alert( tag1.input ); // <h1> <h2>
 
 ## Іменовані групи
 
-Пам’ятати групи за номерами важко. З простими виразами впоратись можна, але з підвищенням рівня складності рахувати дужки стає незручно. Існує кращий варіант: дати імена круглим дужкам.
+Пам'ятати групи за номерами важко. З простими виразами впоратись можна, але з підвищенням рівня складності рахувати дужки стає незручно. Існує кращий варіант: дати імена круглим дужкам.
 
 Робиться це за допомогою `pattern:?<name>` одразу після відкриваючої дужки.
 
@@ -329,7 +329,7 @@ alert( str.replace(regexp, '$<day>.$<month>.$<year>') );
 
 Для прикладу, якщо ми хочемо знайти `pattern:(go)+`, але не потребуємо вміст дужок (`go`) окремим елементом масиву, ми можемо написати: `pattern:(?:go)+`.
 
-В прикладі нижче, ми отримуємо лише ім’я `match:John` окремим елементом збігу:
+В прикладі нижче, ми отримуємо лише ім'я `match:John` окремим елементом збігу:
 
 ```js run
 let str = "Gogogo John!";
@@ -348,7 +348,7 @@ alert( result.length ); // 2 (інших елементів у масиві не
 
 ## Підсумки
 
-Круглі дужки об’єднують в групу частину регулярного виразу, аби повноцінно застосувати до неї квантифікатор.
+Круглі дужки об'єднують в групу частину регулярного виразу, аби повноцінно застосувати до неї квантифікатор.
 
 Групи дужок нумеруються зліва направо та за бажанням можуть бути іменовані за допомогою `(?<name>...)`.
 
@@ -359,6 +359,6 @@ alert( result.length ); // 2 (інших елементів у масиві не
 
 Якщо в дужок нема імені, їх вміст доступний в масиві збігу за їх номером. Іменовані дужки також доступні через властивість `groups`.
 
-Ми також можемо використовувати вміст дужок в рядку для заміни в `str.replace`: за номером `$n` або ім’ям `$<name>`.
+Ми також можемо використовувати вміст дужок в рядку для заміни в `str.replace`: за номером `$n` або ім'ям `$<name>`.
 
 Групу можна виключити з нумерації, додавши `pattern:?:` на її початку. Цей прийом використовується за необхідності застосувати квантифікатор до всієї групи, але без появи окремого елементу в масиві результатів. Також, ми не можемо посилатись на такі дужки в рядку для заміни.
diff --git a/9-regular-expressions/12-regexp-backreferences/article.md b/9-regular-expressions/12-regexp-backreferences/article.md
index 15d20960b..578f4a5d2 100644
--- a/9-regular-expressions/12-regexp-backreferences/article.md
+++ b/9-regular-expressions/12-regexp-backreferences/article.md
@@ -1,4 +1,4 @@
-# Зворотні посилання в шаблоні: \N і \k<ім’я>
+# Зворотні посилання в шаблоні: \N і \k<ім'я>
 
 Вміст груп захоплення `pattern:(...)` можна використовувати не тільки в резульаті пошуку чи рядку заміни, а й також безпосередньо у самому шаблоні.
 
diff --git a/9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md b/9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md
index 0d0c51800..1ea23ab2a 100644
--- a/9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md
+++ b/9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md
@@ -20,7 +20,7 @@ alert( str.match(regexp) ); // Java,Java,PHP,C,C
 Існує два розв'язання цієї проблеми:
 
 1. Змінити порядок, щоб спочатку перевірялись довші співпадіння: `pattern:JavaScript|Java|C\+\+|C|PHP`.
-2. З’єднати варіанти, які починаються однаково: `pattern:Java(Script)?|C(\+\+)?|PHP`.
+2. З'єднати варіанти, які починаються однаково: `pattern:Java(Script)?|C(\+\+)?|PHP`.
 
 У дії:
 
diff --git a/9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md b/9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md
index f75bbf4c2..033a92617 100644
--- a/9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md
+++ b/9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md
@@ -27,6 +27,6 @@ let str = "Як ось \"тут\".";
 ```js run
 let str = ' .. "протестуй мене" .. "Скажи \\"Привіт\\"!" .. "\\\\ \\"" .. ';
 
-// Рядок у пам’яті
+// Рядок у пам'яті
 alert(str); //  .. "протестуй мене" .. "Скажи \"Привіт\"!" .. "\\ \"" ..
 ```
diff --git a/9-regular-expressions/13-regexp-alternation/article.md b/9-regular-expressions/13-regexp-alternation/article.md
index b1a140358..1a83740eb 100644
--- a/9-regular-expressions/13-regexp-alternation/article.md
+++ b/9-regular-expressions/13-regexp-alternation/article.md
@@ -13,7 +13,7 @@
 ```js run
 let regexp = /html|php|css|java(script)?/gi;
 
-let str = "Першим з’явився HTML, потім CSS, далі JavaScript";
+let str = "Першим з'явився HTML, потім CSS, далі JavaScript";
 
 alert( str.match(regexp) ); // 'HTML', 'CSS', 'JavaScript'
 ```
diff --git a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
index b78f70ae9..ff409873a 100644
--- a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
+++ b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
@@ -10,9 +10,9 @@
 
 ## Приклад
 
-Скажімо, ми маємо рядок і хотіли б перевірити його на наявність слів `pattern:\w+` з необов’язковим пробілом `pattern:\s?` після кожного.
+Скажімо, ми маємо рядок і хотіли б перевірити його на наявність слів `pattern:\w+` з необов'язковим пробілом `pattern:\s?` після кожного.
 
-Очевидний спосіб сконструювати регулярний вираз – взяти слово, за яким йде необов’язковий пробіл `pattern:\w+\s?`, та прописати повтор `*`.
+Очевидний спосіб сконструювати регулярний вираз – взяти слово, за яким йде необов'язковий пробіл `pattern:\w+\s?`, та прописати повтор `*`.
 
 Це приведе нас до регулярного виразу `pattern:^(\w+\s?)*$`, який описує 0+ таких слів, починається з `pattern:^` та закінчується на `pattern:$`.
 
@@ -174,7 +174,7 @@ alert( regexp.test(str) );
 
 З точки зору людини, збігу не може бути, бо рядок закінчується знаком `!`, але регулярний вираз в кінці очікує символ “слова” `pattern:\w` або пробіл `pattern:\s`. Але рушій цього не знає.
 
-Він перебирає всі комбінації "поглинання" рядку регулярним виразом `pattern:(\w+\s?)*`, включаючи варіанти з пробілами `pattern:(\w+\s)*` та без `pattern:(\w+)*` (бо пробіли `pattern:\s?` необов’язкові). Пошук є тривалим через велику кількість комбінацій (як на прикладі цифр).
+Він перебирає всі комбінації "поглинання" рядку регулярним виразом `pattern:(\w+\s?)*`, включаючи варіанти з пробілами `pattern:(\w+\s)*` та без `pattern:(\w+)*` (бо пробіли `pattern:\s?` необов'язкові). Пошук є тривалим через велику кількість комбінацій (як на прикладі цифр).
 
 Що робити?
 
@@ -190,7 +190,7 @@ alert( regexp.test(str) );
 
 Перший – знизити кількість можливих комбінацій.
 
-Зробимо пробіл обов’язковим, переписавши регулярний вираз як `pattern:^(\w+\s)*\w*$` - ми шукатимемо будь-яку кількість слів та пробіл опісля `pattern:(\w+\s)*`, далі (необов’язково) останнє слово `pattern:\w*`.
+Зробимо пробіл обов'язковим, переписавши регулярний вираз як `pattern:^(\w+\s)*\w*$` - ми шукатимемо будь-яку кількість слів та пробіл опісля `pattern:(\w+\s)*`, далі (необов'язково) останнє слово `pattern:\w*`.
 
 Цей регулярний вираз рівноцінний попередньому (збіг той самий) та працює відмінно:
 
@@ -203,7 +203,7 @@ alert( regexp.test(str) ); // false
 
 Чому проблема зникла?
 
-Бо тепер пробіл є обов’язковим.
+Бо тепер пробіл є обов'язковим.
 
 Попередній регулярний вираз, якщо не врахувати пробіл, стає `pattern:(\w+)*`, призводячи до багатьох комбінацій `\w+` посеред єдиного слова.
 
@@ -214,7 +214,7 @@ alert( regexp.test(str) ); // false
 (inp)(ut)
 ```
 
-Новий шаблон інший: `pattern:(\w+\s)*` описує повторення слів, за якими йде пробіл! Рядок `subject:input` не буде збігом для двох повторень `pattern:\w+\s`, оскільки пробіл є обов’язковим.
+Новий шаблон інший: `pattern:(\w+\s)*` описує повторення слів, за якими йде пробіл! Рядок `subject:input` не буде збігом для двох повторень `pattern:\w+\s`, оскільки пробіл є обов'язковим.
 
 Час проходження великою кількістю (взагалі-то, більшістю) комбінацій зекономлено.
 
@@ -261,7 +261,7 @@ alert( regexp.test(str) ); // false
 Розберемо його:
 
 - Перегляд вперед `pattern:?=` шукає найдовше слово `pattern:\w+`, починаючи з поточної позиції.
-- Вміст дужок з `pattern:?=...` не запам’ятовується рушієм, тож огорнемо дужками `pattern:\w+`. В цьому випадку, рушій запам’ятає вміст дужок.
+- Вміст дужок з `pattern:?=...` не запам'ятовується рушієм, тож огорнемо дужками `pattern:\w+`. В цьому випадку, рушій запам'ятає вміст дужок.
 - ...Це дозволяє нам посилатись на них всередині шаблону: `pattern:\1`.
 
 Тобто, ми дивимось вперед – якщо там є слово `pattern:\w+`, то воно відмітиться як `pattern:\1`.
@@ -283,7 +283,7 @@ alert( "JavaScript".match(/(?=(\w+))\1Script/)); // null
 Ми можемо помістити більш комплексний регулярний вираз у `pattern:(?=(\w+))\1` замість `pattern:\w`, коли нам потрібно заборонити пошук з поверненням для `pattern:+` після нього.
 
 ```smart
-Більше про зв’язок між присвійними квантифікаторами та переглядом вперед в статтях [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](https://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) та [Mimicking Atomic Groups](https://blog.stevenlevithan.com/archives/mimic-atomic-groups).
+Більше про зв'язок між присвійними квантифікаторами та переглядом вперед в статтях [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](https://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) та [Mimicking Atomic Groups](https://blog.stevenlevithan.com/archives/mimic-atomic-groups).
 ```
 
 Перепишемо перший приклад, використовуючи перегляд вперед для запобігання пошуку з поверненням:
@@ -301,7 +301,7 @@ alert( regexp.test(str) ); // false, працює швидко!
 Як бачимо, `pattern:\2` використовується замість `pattern:\1` через додаткові зовнішні дужки. Щоб уникнути плутанини з числами, ми можемо назвати дужки, наприклад, `pattern:(?<word>\w+)`.
 
 ```js run
-// дужки мають ім’я ?<word>, на що посилається \k<word>
+// дужки мають ім'я ?<word>, на що посилається \k<word>
 let regexp = /^((?=(?<word>\w+))\k<word>\s?)*$/;
 
 let str = "Введений рядок, який оброблятиметься довго або навіть спровокує зависання регулярного виразу!";
diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index d66299375..fe793bc9c 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -63,9 +63,9 @@
 
 Існує 3 відмінності від `match`:
 
-1. Він повертає ітерований об’єкт із збігами замість масиву. Ми можемо отримати з нього звичайний масив за допомогою `Array.from`.
+1. Він повертає ітерований об'єкт із збігами замість масиву. Ми можемо отримати з нього звичайний масив за допомогою `Array.from`.
 2. Кожен збіг повертається у вигляді масиву з групами захоплення (той самий формат, що й `str.match` без прапору `pattern:g`).
-3. Якщо результатів нема, метод повертає порожній ітерований об’єкт замість `null`.
+3. Якщо результатів нема, метод повертає порожній ітерований об'єкт замість `null`.
 
 Приклад використання:
 
@@ -135,7 +135,7 @@ alert('12-34-56'.replace("-", ":")) // 12:34-56
 
 Ви можете побачити це в попередньому прикладі: лише перше `"-"` замінюється на `":"`.
 
-Аби знайти всі дефіси, нам потрібно використати не рядок `"-"`, а регулярний вираз `pattern:/-/g`, з обов’язковим прапором `pattern:g`:
+Аби знайти всі дефіси, нам потрібно використати не рядок `"-"`, а регулярний вираз `pattern:/-/g`, з обов'язковим прапором `pattern:g`:
 
 ```js run
 // заміна всіх дефісів на двокрапку
@@ -158,7 +158,7 @@ alert( '12-34-56'.replace( *!*/-/g*/!*, ":" ) )  // 12:34:56
 ```js run
 let str = "Іван Сірко";
 
-// переставляє місцями ім’я та прізвище
+// переставляє місцями ім'я та прізвище
 alert(str.replace(/(іван) (сірко)/i, '$2, $1')) // Сірко, Іван
 ```
 
@@ -172,7 +172,7 @@ alert(str.replace(/(іван) (сірко)/i, '$2, $1')) // Сірко, Іван
 2. `p1, p2, ..., pn` -- вміст груп захоплення (якщо є в наявності),
 3. `offset` -- позиція збігу,
 4. `input` -- вихідний рядок,
-5. `groups` -- об’єкт з іменованими групами.
+5. `groups` -- об'єкт з іменованими групами.
 
 Якщо в регулярному виразі нема дужок, тоді є лише 3 аргументи: `func(str, offset, input)`.
 
@@ -212,7 +212,7 @@ let result = str.replace(/(\w+) (\w+)/, (...match) => `${match[2]}, ${match[1]}`
 alert(result); // Сірко, Іван
 ```
 
-В іншому випадку, якщо ми використовуємо іменовані групи, тоді об’єкт `groups` завжди йде останнім після них, тож ми можемо отримати його наступним чином:
+В іншому випадку, якщо ми використовуємо іменовані групи, тоді об'єкт `groups` завжди йде останнім після них, тож ми можемо отримати його наступним чином:
 
 ```js run
 let str = "Іван Сірко";
@@ -286,7 +286,7 @@ while (result = regexp.exec(str)) {
 let str = 'Вітаю, світе!';
 
 let regexp = /\w+/g; // без прапору "g", властивість lastIndex ігнорується
-regexp.lastIndex = 5; // пошук з п’ятої позиції (з коми)
+regexp.lastIndex = 5; // пошук з п'ятої позиції (з коми)
 
 alert( regexp.exec(str) ); // світе
 ```

From e70cc1a74fad71d85c3ef4b79f9987137dbfd0dc Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:52:28 +0300
Subject: [PATCH 10/11] =?UTF-8?q?feat(README.md):=20Changed=20all=20apostr?=
 =?UTF-8?q?ophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 12bcc3135..7d0a23a2b 100755
--- a/README.md
+++ b/README.md
@@ -38,9 +38,9 @@
 
 🎉 Дякуємо!
 
-> **Обов’язково ознайомтеся з [рекомендаціями щодо перекладу](https://github.com/javascript-tutorial/uk.javascript.info/blob/master/TRANSLATION.md)!**
+> **Обов'язково ознайомтеся з [рекомендаціями щодо перекладу](https://github.com/javascript-tutorial/uk.javascript.info/blob/master/TRANSLATION.md)!**
 
-Коли переклад або виправлення буде опубліковано, Ваше ім’я та Ваш вклад в переклад з’являться в [таблиці подяки](#подяка-) нижче.
+Коли переклад або виправлення буде опубліковано, Ваше ім'я та Ваш вклад в переклад з'являться в [таблиці подяки](#подяка-) нижче.
 
 Якщо Ви хочете стати супроводжуючим (maintainer), мати доступ до репозиторію і переглядати переклади інших, напишіть про свій намір [в цьому обговоренні](https://github.com/javascript-tutorial/uk.javascript.info/issues/169).
 

From 94ec6079341a1479eba8cada09df8fb69323e11c Mon Sep 17 00:00:00 2001
From: ltlaitoff <ltlaitoff@gmail.com>
Date: Fri, 15 Sep 2023 16:53:50 +0300
Subject: [PATCH 11/11] =?UTF-8?q?feat(TRANSLATION.md):=20Changed=20all=20a?=
 =?UTF-8?q?postrophes=20from=20=E2=80=99=20to=20'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 TRANSLATION.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/TRANSLATION.md b/TRANSLATION.md
index 9cf7d4351..d0f088aba 100644
--- a/TRANSLATION.md
+++ b/TRANSLATION.md
@@ -1,11 +1,11 @@
 ## Рекомендації щодо перекладу
 
-- Переклад не обов’яково повинен бути дослівним. Він повинен бути без помилок, правильним і **зрозумілим**.
+- Переклад не обов'яково повинен бути дослівним. Він повинен бути без помилок, правильним і **зрозумілим**.
 - Якщо ви бачите, що англійську версію можна вдосконалити — чудово, будь ласка, надішліть PR із правками.
 
 > **Важливо!**
 >
-> Будь ласка, зберігайте перенесення рядків (пусті рядки) і структуру абзаців "як є": не додавайте нові рядки і не видаляйте існуючі. Це полегшує об’єднання майбутніх змін в англійській версії з цим перекладом.
+> Будь ласка, зберігайте перенесення рядків (пусті рядки) і структуру абзаців "як є": не додавайте нові рядки і не видаляйте існуючі. Це полегшує об'єднання майбутніх змін в англійській версії з цим перекладом.
 
 ### Текст в блоках коду
 
@@ -90,7 +90,7 @@ Interested to see which characters belong to a property?
 Прочитайте про генерацію перекладу [тут](https://github.com/javascript-tutorial/server#translating-images).
 
 Після генерації перекладу, потрібно відкорегувати розташування перекладеного тексту в svg файлі.
-Для цього потрібно змінювати атрибути `x` та `y` для тега `<tspan>` безпосередньо в svg файлі. Значення `x` та `y` повинні бути цілим числом (також можуть бути від’ємними).
+Для цього потрібно змінювати атрибути `x` та `y` для тега `<tspan>` безпосередньо в svg файлі. Значення `x` та `y` повинні бути цілим числом (також можуть бути від'ємними).
 
 Щоб змінювати розмір тексту потрібно редагувати атрибут `font-size="14"` для тега `<text>`.
 
@@ -99,7 +99,7 @@ Interested to see which characters belong to a property?
 - Слово "_ви_" і його відмінки пишіть з маленької літери.
 - Не знаєте, як перекласти термін? [Словник «Веб-стандартів»](https://github.com/web-standards-ru/dictionary/blob/master/dictionary.md) допоможе (російською мовою)!
 - Назви компаній (Google), бібліотек (Jest) і абревіатури (DOM) не перекладаються.
-- Апостроф потрібно писати знаком `’`, а не одинарною лапкою `'`.
+- Апостроф потрібно писати знаком `'`.
 - Власні назви перекладайте на український лад: `let userName = "John"` => `let userName = "Іван"`, `let userName = "Pete"` => `let userName = "Петро"`.
 
 ### Глосарій (словник)