From 05bb8959ccbe0d38f4ffe0622bea9399e488b348 Mon Sep 17 00:00:00 2001
From: MrsMelnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Thu, 24 Nov 2022 17:39:09 +0200
Subject: [PATCH 01/24] Sets and ranges [...]

---
 .../article.md                                | 170 +++++++++---------
 1 file changed, 85 insertions(+), 85 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index a1b8f896d..f99f83713 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -1,169 +1,169 @@
-# Sets and ranges [...]
+# Набори та діапазони [...]
 
-Several characters or character classes inside square brackets `[…]` mean to "search for any character among given".
+Декільки символів, або класи символів всередині квадратних дужок `[…]` означають "шукати будь-який символ з-поміж заданих".
 
-## Sets
+## Набори
 
-For instance, `pattern:[eao]` means any of the 3 characters: `'a'`, `'e'`, or `'o'`.
+До прикладу, `pattern:[eao]` означає будь-який з трьох символів: `'a'`, `'e'`, or `'o'`.
 
-That's called a *set*. Sets can be used in a regexp along with regular characters:
+У такий спосіб записується так званий *набір*. Набір може використовуватись в регулярних виразах разом зі звичайними символами:
 
 ```js run
-// find [t or m], and then "op"
+// знайти [t або m], а потім "op"
 alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top"
 ```
 
-Please note that although there are multiple characters in the set, they correspond to exactly one character in the match.
+Зверніть увагу, що незважаючи на те, що в наборі вказано два символи, в результаті є співпадіння лише по одному з них.
 
-So the example below gives no matches:
+Тож нижченаведений приклад не знайде співпадінь:
 
 ```js run
-// find "V", then [o or i], then "la"
+// знайти "V", потім [o чи i], потім "la"
 alert( "Voila".match(/V[oi]la/) ); // null, no matches
 ```
 
-The pattern searches for:
+Шаблон шукає:
 
 - `pattern:V`,
-- then *one* of the letters `pattern:[oi]`,
-- then `pattern:la`.
+- потім *одна* з літер набору `pattern:[oi]`,
+- потім `pattern:la`.
 
-So there would be a match for `match:Vola` or `match:Vila`.
+Результатом такого пошуку могли б стати варіанти `match:Vola` або `match:Vila`.
 
-## Ranges
+## Діапазони
 
-Square brackets may also contain *character ranges*.
+Квадратні дужки також можуть містити *діапазони символів*.
 
-For instance, `pattern:[a-z]` is a character in range from `a` to `z`, and `pattern:[0-5]` is a digit from `0` to `5`.
+До прикладу, `pattern:[a-z]` шукатиме символу в діапазоні від `a` до `z`, а `pattern:[0-5]` дорівнює цифрам в діапазоні від `0` до `5`.
 
-In the example below we're searching for `"x"` followed by two digits or letters from `A` to `F`:
+В нижченаведеному прикладі ми шукатимемо літеру `"x"` за якою слідують дві цифри, або літери від `A` до `F`:
 
 ```js run
 alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 ```
 
-Here `pattern:[0-9A-F]` has two ranges: it searches for a character that is either a digit from `0` to `9` or a letter from `A` to `F`.
+Тут `pattern:[0-9A-F]` має в собі одразу два діапазони: він шукає на символ, який є або цифрою від `0` до `9` , або літерою від `A` до `F`.
 
-If we'd like to look for lowercase letters as well, we can add the range `a-f`: `pattern:[0-9A-Fa-f]`. Or add the flag `pattern:i`.
+Якби ми захотіли шукати літери не тільки верхнього, а й нижнього регістру, ми могли б додати діапазон `a-f`: `pattern:[0-9A-Fa-f]`. Або додати флаг `pattern:i`.
 
-We can also use character classes inside `[…]`.
+Крім того, всередині `[…]` ми можемо використовувати символьні класи.
 
-For instance, if we'd like to look for a wordly character `pattern:\w` or a hyphen `pattern:-`, then the set is `pattern:[\w-]`.
+До прикладу, якщо ми захочемо знайти "символ слова" `pattern:\w` , або дефіс `pattern:-`, набір виглядатиме наступним чином `pattern:[\w-]`.
 
-Combining multiple classes is also possible, e.g. `pattern:[\s\d]` means "a space character or a digit".
+Комбінувати декілька класів теж можливо, наприклад `pattern:[\s\d]` означає "пробіл, або цифра".
 
-```smart header="Character classes are shorthands for certain character sets"
-For instance:
+```smart header="Символьні класи це всього лише скорочення для деяких наборів символів"
+До прикладу:
 
-- **\d** -- is the same as `pattern:[0-9]`,
-- **\w** -- is the same as `pattern:[a-zA-Z0-9_]`,
-- **\s** -- is the same as `pattern:[\t\n\v\f\r ]`, plus few other rare Unicode space characters.
+- **\d** -- це те саме, що `pattern:[0-9]`,
+- **\w** -- це те саме, що `pattern:[a-zA-Z0-9_]`,
+- **\s** -- це те саме, що `pattern:[\t\n\v\f\r ]`, плюс деякілька інших рідких пробільних символів Unicode.
 ```
 
-### Example: multi-language \w
+### Приклад: \w в інших мовах світу
 
-As the character class `pattern:\w` is a shorthand for `pattern:[a-zA-Z0-9_]`, it can't find Chinese hieroglyphs, Cyrillic letters, etc.
+Оскільки символьний клас `pattern:\w` це лише скорочений запис `pattern:[a-zA-Z0-9_]`, він не зможе знайти китайські ієрогліфи, літери кирилицею і т.д.
 
-We can write a more universal pattern, that looks for wordly characters in any language. That's easy with Unicode properties: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
+Існує спосіб написати більш універсальний шаблон, що включатиме в себе буквенні символи будь-якої мови світу. Це легко реалізувати завдяки властивостям Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 
-Let's decipher it. Similar to `pattern:\w`, we're making a set of our own that includes characters with following Unicode properties:
+Давайте розшифруємо цей шаблон. Подібно до `pattern:\w`, ми створюємо свій діапазон, який включає в себе символи з наступними властивостями Unicode:
 
-- `Alphabetic` (`Alpha`) - for letters,
-- `Mark` (`M`) - for accents,
-- `Decimal_Number` (`Nd`) - for digits,
-- `Connector_Punctuation` (`Pc`) - for the underscore `'_'` and similar characters,
-- `Join_Control` (`Join_C`) - two special codes `200c` and `200d`, used in ligatures, e.g. in Arabic.
+- `Alphabetic` (`Alpha`) - для літер,
+- `Mark` (`M`) - для акцентів,
+- `Decimal_Number` (`Nd`) - для цифр,
+- `Connector_Punctuation` (`Pc`) - для нижнього підкреслення `'_'` і тому подібних символів,
+- `Join_Control` (`Join_C`) - два спеціальних коди `200c` та `200d`, які використовуються у лігатурах, зокрема в арабській мові.
 
-An example of use:
+Шаблон в дії:
 
 ```js run
 let regexp = /[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]/gu;
 
 let str = `Hi 你好 12`;
 
-// finds all letters and digits:
+// знайти всі літери та цифри:
 alert( str.match(regexp) ); // H,i,你,好,1,2
 ```
 
-Of course, we can edit this pattern: add Unicode properties or remove them. Unicode properties are covered in more details in the article <info:regexp-unicode>.
+Звичайно, ми можемо редагувати вищенаведений шаблон: додавати Unicode властивості, або видаляти їх. Дізнатись більше про Unicode властивості можна за посиланням <info:regexp-unicode>.
 
-```warn header="Unicode properties aren't supported in IE"
-Unicode properties `pattern:p{…}` are not implemented in IE. If we really need them, we can use library [XRegExp](http://xregexp.com/).
+```warn header="Internet Explorer не підтримує Unicode властивості"
+Unicode властивості `pattern:p{…}` недоступні у Internet Explorer. ЯВтім, якщо вони нам все ж потрібні, ми можемо скористатись бібліотекою [XRegExp](http://xregexp.com/).
 
-Or just use ranges of characters in a language that interests us, e.g.  `pattern:[а-я]` for Cyrillic letters.
+або просто вказати діапазон потрібних нам символів певною мовою, наприклад  `pattern:[а-я]` для літер кирилицею.
 ```
 
-## Excluding ranges
+## Діапазони виключень
 
-Besides normal ranges, there are "excluding" ranges that look like `pattern:[^…]`.
+Окрім звичайни діапазонів, існують діапазони "виключень" які виглядають наступним чином: `pattern:[^…]`.
 
-They are denoted by a caret character `^` at the start and match any character *except the given ones*.
+Вони відрізняються символом каретки `^` на початку і знаходять будь-який символ *окрім вказаних в діапазоні*.
 
-For instance:
+До прикладу:
 
-- `pattern:[^aeyo]` -- any character except  `'a'`, `'e'`, `'y'` or `'o'`.
-- `pattern:[^0-9]` -- any character except a digit, the same as `pattern:\D`.
-- `pattern:[^\s]` -- any non-space character, same as `\S`.
+- `pattern:[^aeyo]` -- будь-який символ окрім  `'a'`, `'e'`, `'y'` or `'o'`.
+- `pattern:[^0-9]` -- будь-який символ окрім цифр, так само як і `pattern:\D`.
+- `pattern:[^\s]` -- будь-який не пробільний символ `\S`.
 
-The example below looks for any characters except letters, digits and spaces:
+Нижченаведений приклад шукає будь-який символ окрім літер латиницею, цифр та пробільних символів:
 
 ```js run
-alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ and .
+alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ та .
 ```
 
-## Escaping in […]
+## Екранування всередині […]
 
-Usually when we want to find exactly a special character, we need to escape it like `pattern:\.`. And if we need a backslash, then we use `pattern:\\`, and so on.
+Зазвичай, коли ми хочемо знайти один зі спец символів, нам потрібно екранувати його наступним чином `pattern:\.`. Тобто, якщо нам потрібна зворотня коса риска, ми маємо писати `pattern:\\`, і  так далі.
 
-In square brackets we can use the vast majority of special characters without escaping:
+В квадратних дужках ми можемо використовувати велику кількість спец символів без екранування:
 
-- Symbols `pattern:. + ( )` never need escaping.
-- A hyphen `pattern:-` is not escaped in the beginning or the end (where it does not define a range).
-- A caret `pattern:^` is only escaped in the beginning (where it means exclusion).
-- The closing square bracket `pattern:]` is always escaped (if we need to look for that symbol).
+- Символ `pattern:. + ( )` не потребує екранування.
+- Дефіс `pattern:-` не потребує екранування на початку, або в кінці (тобто коли не може означати діапазон).
+- Каретка `pattern:^` екранується лише на початку (без екранування означає набір символів-виключень).
+- Закриваюча квадратна дужка `pattern:]` завжди потребує екранування (у випадках, коли нам потрібно знайти цей символ).
 
-In other words, all special characters are allowed without escaping, except when they mean something for square brackets.
+Інакше кажучи, всі спец символи можна використовувати без екранування тоді, коли вони не мають додаткового значення в квадратних дужках.
 
-A dot `.` inside square brackets means just a dot. The pattern `pattern:[.,]` would look for one of characters: either a dot or a comma.
+Крапка `.` всередині квадратних дужок означає просто крапку. Шаблон `pattern:[.,]` шукатиме на один з двох символів, або крапку, або кому.
 
-In the example below the regexp `pattern:[-().^+]` looks for one of the characters `-().^+`:
+В нижченаведеному прикладі регулярний вираз `pattern:[-().^+]` шукає один з вказаних символів `-().^+`:
 
 ```js run
-// No need to escape
+// Не потрібно екранувати
 let regexp = /[-().^+]/g;
 
-alert( "1 + 2 - 3".match(regexp) ); // Matches +, -
+alert( "1 + 2 - 3".match(regexp) ); // Знаходить +, -
 ```
 
-...But if you decide to escape them "just in case", then there would be no harm:
+...Але якщо ви вирішите все ж таки екранувати їх, "про всяк випадок", гірше від того не буде:
 
 ```js run
-// Escaped everything
+// Всі символи екрановані
 let regexp = /[\-\(\)\.\^\+]/g;
 
-alert( "1 + 2 - 3".match(regexp) ); // also works: +, -
+alert( "1 + 2 - 3".match(regexp) ); // так само находить: +, -
 ```
 
-## Ranges and flag "u"
+## Діапазони і прапор "u"
 
-If there are surrogate pairs in the set, flag `pattern:u` is required for them to work correctly.
+Якщо в діапазоні є сурогатні пари, для коректної роботи регулярного виразу, прапор `pattern:u` є обов'язковим.
 
-For instance, let's look for `pattern:[𝒳𝒴]` in the string `subject:𝒳`:
+До прикладу, давайте знайдемо `pattern:[𝒳𝒴]` у рядку `subject:𝒳`:
 
 ```js run
-alert( '𝒳'.match(/[𝒳𝒴]/) ); // shows a strange character, like [?]
-// (the search was performed incorrectly, half-character returned)
+alert( '𝒳'.match(/[𝒳𝒴]/) ); // виводить дивний символ, схожий на [?]
+// (пошук було виконано некореткно, повернуто тільки половину символу)
 ```
 
-The result is incorrect, because by default regular expressions "don't know" about surrogate pairs.
+Результат є некоректним, оскільки за замовчуванням регулярні вирази "не знають" про сурогатні пари.
 
-The regular expression engine thinks that `[𝒳𝒴]` -- are not two, but four characters:
-1. left half of `𝒳` `(1)`,
-2. right half of `𝒳` `(2)`,
-3. left half of `𝒴` `(3)`,
-4. right half of `𝒴` `(4)`.
+Регулярний вираз сприймає `[𝒳𝒴]` -- не як два, а як чотири символи:
+1. ліва половина `𝒳` `(1)`,
+2. права половина `𝒳` `(2)`,
+3. ліва половина `𝒴` `(3)`,
+4. права половина `𝒴` `(4)`.
 
-We can see their codes like this:
+Якщо вивести їх кодове значення ми побачимо наступне:
 
 ```js run
 for(let i=0; i<'𝒳𝒴'.length; i++) {
@@ -171,27 +171,27 @@ for(let i=0; i<'𝒳𝒴'.length; i++) {
 };
 ```
 
-So, the example above finds and shows the left half of `𝒳`.
+Отже, вищенаведений приклад знайшов і вивів ліву половину `𝒳`.
 
-If we add flag `pattern:u`, then the behavior will be correct:
+Якщо ми додамо прапор `pattern:u`, то поведінка буде коректною:
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 ```
 
-The similar situation occurs when looking for a range, such as `[𝒳-𝒴]`.
+Подібна ситуація складається коли ми шукаємо в діапазоні, наприклад `[𝒳-𝒴]`.
 
-If we forget to add flag `pattern:u`, there will be an error:
+Якщо ми забудемо додати прапор `pattern:u`, то отримаємо помилку:
 
 ```js run
 '𝒳'.match(/[𝒳-𝒴]/); // Error: Invalid regular expression
 ```
 
-The reason is that without flag `pattern:u` surrogate pairs are perceived as two characters, so `[𝒳-𝒴]` is interpreted as `[<55349><56499>-<55349><56500>]` (every surrogate pair is replaced with its codes). Now it's easy to see that the range `56499-55349` is invalid: its starting code `56499` is greater than the end `55349`. That's the formal reason for the error.
+Причина в тому, що без прапору `pattern:u` сурогатні пари сприймаються як два окремих символи, тобто `[𝒳-𝒴]` оброблюються як `[<55349><56499>-<55349><56500>]` (кожна сурогатна пара замінюється на набір кодів). Таким чином, ми бачимо, що діапазон `56499-55349` є некоректним: його початковий номер `56499` більший за останній `55349`. Це і є причиною помилки.
 
-With the flag `pattern:u` the pattern works correctly:
+З прапором `pattern:u` шаблон працює коректно:
 
 ```js run
-// look for characters from 𝒳 to 𝒵
+// шукає символи від 𝒳 до 𝒵
 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴
 ```

From a38fb86ef0e966acd8e6498120be73a5e08b975b Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:08 +0200
Subject: [PATCH 02/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index f99f83713..f93779ea5 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -42,7 +42,7 @@ alert( "Voila".match(/V[oi]la/) ); // null, no matches
 alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 ```
 
-Тут `pattern:[0-9A-F]` має в собі одразу два діапазони: він шукає на символ, який є або цифрою від `0` до `9` , або літерою від `A` до `F`.
+Тут `pattern:[0-9A-F]` має в собі одразу два діапазони: він шукає символ, який є або цифрою від `0` до `9` , або літерою від `A` до `F`.
 
 Якби ми захотіли шукати літери не тільки верхнього, а й нижнього регістру, ми могли б додати діапазон `a-f`: `pattern:[0-9A-Fa-f]`. Або додати флаг `pattern:i`.
 

From a2981670c0c4e88387f031162f99496ff6efdaea Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:18 +0200
Subject: [PATCH 03/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index f93779ea5..55313eca8 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -48,7 +48,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 
 Крім того, всередині `[…]` ми можемо використовувати символьні класи.
 
-До прикладу, якщо ми захочемо знайти "символ слова" `pattern:\w` , або дефіс `pattern:-`, набір виглядатиме наступним чином `pattern:[\w-]`.
+До прикладу, якщо ми захочемо знайти символ "слова"  `pattern:\w` , або дефіс `pattern:-`, набір виглядатиме наступним чином `pattern:[\w-]`.
 
 Комбінувати декілька класів теж можливо, наприклад `pattern:[\s\d]` означає "пробіл, або цифра".
 

From be0ffd71df15a93f88d77763d63d72d42de6fbcc Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:27 +0200
Subject: [PATCH 04/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 55313eca8..d4b5ae338 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -52,7 +52,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 
 Комбінувати декілька класів теж можливо, наприклад `pattern:[\s\d]` означає "пробіл, або цифра".
 
-```smart header="Символьні класи це всього лише скорочення для деяких наборів символів"
+```smart header="Символьні класи це лише скорочення для деяких наборів символів"
 До прикладу:
 
 - **\d** -- це те саме, що `pattern:[0-9]`,

From e0510a8b29819145b31e8141fdcccdcd80fb31f5 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:34 +0200
Subject: [PATCH 05/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index d4b5ae338..423d8112d 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -55,7 +55,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 ```smart header="Символьні класи це лише скорочення для деяких наборів символів"
 До прикладу:
 
-- **\d** -- це те саме, що `pattern:[0-9]`,
+- **\d** -- це те саме, що й `pattern:[0-9]`,
 - **\w** -- це те саме, що `pattern:[a-zA-Z0-9_]`,
 - **\s** -- це те саме, що `pattern:[\t\n\v\f\r ]`, плюс деякілька інших рідких пробільних символів Unicode.
 ```

From e8715320ef4fc6bb659b4e25a84b6a78a01dde5a Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:42 +0200
Subject: [PATCH 06/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 423d8112d..5842c7c04 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -56,7 +56,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 До прикладу:
 
 - **\d** -- це те саме, що й `pattern:[0-9]`,
-- **\w** -- це те саме, що `pattern:[a-zA-Z0-9_]`,
+- **\w** -- це те саме, що й `pattern:[a-zA-Z0-9_]`,
 - **\s** -- це те саме, що `pattern:[\t\n\v\f\r ]`, плюс деякілька інших рідких пробільних символів Unicode.
 ```
 

From 120682963806e40a7883d348b76f5e6db9128ced Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:49 +0200
Subject: [PATCH 07/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 5842c7c04..550b2ea26 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -146,7 +146,7 @@ alert( "1 + 2 - 3".match(regexp) ); // так само находить: +, -
 
 ## Діапазони і прапор "u"
 
-Якщо в діапазоні є сурогатні пари, для коректної роботи регулярного виразу, прапор `pattern:u` є обов'язковим.
+Якщо в діапазоні є сурогатні пари, для коректної роботи регулярного виразу, прапорець `pattern:u` є обов'язковим.
 
 До прикладу, давайте знайдемо `pattern:[𝒳𝒴]` у рядку `subject:𝒳`:
 

From 579dc3b928afd812b80e8b3bf978b80a98ed0cc2 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:33:57 +0200
Subject: [PATCH 08/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 550b2ea26..d80779d3c 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -173,7 +173,7 @@ for(let i=0; i<'𝒳𝒴'.length; i++) {
 
 Отже, вищенаведений приклад знайшов і вивів ліву половину `𝒳`.
 
-Якщо ми додамо прапор `pattern:u`, то поведінка буде коректною:
+Якщо ми додамо прапорець `pattern:u`, то поведінка буде коректною:
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳

From 8f67d1d6642c81f755f8ae27aaccbec01b8ca2ca Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:34:04 +0200
Subject: [PATCH 09/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index d80779d3c..b6f68e422 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -181,7 +181,7 @@ alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 
 Подібна ситуація складається коли ми шукаємо в діапазоні, наприклад `[𝒳-𝒴]`.
 
-Якщо ми забудемо додати прапор `pattern:u`, то отримаємо помилку:
+Якщо ми забудемо додати прапорець `pattern:u`, то отримаємо помилку:
 
 ```js run
 '𝒳'.match(/[𝒳-𝒴]/); // Error: Invalid regular expression

From aeeda3ae3f798ec3781e2e019d5fe5cfeb675280 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:34:09 +0200
Subject: [PATCH 10/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index b6f68e422..9bd803cb8 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -187,7 +187,7 @@ alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 '𝒳'.match(/[𝒳-𝒴]/); // Error: Invalid regular expression
 ```
 
-Причина в тому, що без прапору `pattern:u` сурогатні пари сприймаються як два окремих символи, тобто `[𝒳-𝒴]` оброблюються як `[<55349><56499>-<55349><56500>]` (кожна сурогатна пара замінюється на набір кодів). Таким чином, ми бачимо, що діапазон `56499-55349` є некоректним: його початковий номер `56499` більший за останній `55349`. Це і є причиною помилки.
+Причина в тому, що без прапорцю `pattern:u` сурогатні пари сприймаються як два окремих символи, тобто `[𝒳-𝒴]` обробляються як `[<55349><56499>-<55349><56500>]` (кожна сурогатна пара замінюється на набір кодів). Таким чином, ми бачимо, що діапазон `56499-55349` є некоректним: його початковий номер `56499` більший за останній `55349`. Це і є причиною помилки.
 
 З прапором `pattern:u` шаблон працює коректно:
 

From 600e01f7eb42a1b30e24f02589b8c5e9139ba91e Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:34:16 +0200
Subject: [PATCH 11/24] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: Stanislav <s.dolgachov@gmail.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 9bd803cb8..303124a43 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -189,7 +189,7 @@ alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 
 Причина в тому, що без прапорцю `pattern:u` сурогатні пари сприймаються як два окремих символи, тобто `[𝒳-𝒴]` обробляються як `[<55349><56499>-<55349><56500>]` (кожна сурогатна пара замінюється на набір кодів). Таким чином, ми бачимо, що діапазон `56499-55349` є некоректним: його початковий номер `56499` більший за останній `55349`. Це і є причиною помилки.
 
-З прапором `pattern:u` шаблон працює коректно:
+З прапорцем `pattern:u` шаблон працює коректно:
 
 ```js run
 // шукає символи від 𝒳 до 𝒵

From c02a73051aad00074da513190dba4ba53573c031 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:36:55 +0200
Subject: [PATCH 12/24] Update solution.md

---
 .../2-find-time-2-formats/solution.md                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index 69ade1b19..7ea45c310 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -1,4 +1,4 @@
-Answer: `pattern:\d\d[-:]\d\d`.
+Відповідь: `pattern:\d\d[-:]\d\d`.
 
 ```js run
 let regexp = /\d\d[-:]\d\d/g;

From d5189882eda893f34e9f5e79972f7eea47f68733 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:41:04 +0200
Subject: [PATCH 13/24] Update solution.md

---
 .../2-find-time-2-formats/solution.md                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index 7ea45c310..ec1b16fe6 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -5,4 +5,4 @@ let regexp = /\d\d[-:]\d\d/g;
 alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-Please note that the dash `pattern:'-'` has a special meaning in square brackets, but only between other characters, not when it's in the beginning or at the end, so we don't need to escape it.
+Зверніть увагу, що риска `pattern:'-'` має спеціальне значення у квартратних дужкахб але тільки між іншими символами, не на початку чи в кінці виразу, тож немає необхідності її екранувати.

From b5ee3bdb70fa4dd2051695f595f47f81294eb963 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:41:35 +0200
Subject: [PATCH 14/24] Update solution.md

---
 .../2-find-time-2-formats/solution.md                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index ec1b16fe6..d1e53155c 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -2,7 +2,7 @@
 
 ```js run
 let regexp = /\d\d[-:]\d\d/g;
-alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
+alert( "Сніданок о 09:00. Вечеря о 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
 Зверніть увагу, що риска `pattern:'-'` має спеціальне значення у квартратних дужкахб але тільки між іншими символами, не на початку чи в кінці виразу, тож немає необхідності її екранувати.

From a519a464eb0311b25ce42fb0d38bc7097e8f9827 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:44:53 +0200
Subject: [PATCH 15/24] Update task.md

---
 .../2-find-time-2-formats/task.md                      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index c8441caf4..49ddd42ca 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -1,12 +1,12 @@
-# Find the time as hh:mm or hh-mm
+# Знайдіть часовий формат hh:mm або hh-mm
 
-The time can be in the format `hours:minutes` or `hours-minutes`. Both hours and minutes have 2 digits:  `09:00` or `21-30`.
+Час можна записати у форматі `години:хвилини` or `години-хвилини`. В будь-яку з варіантів потрібні дві цифри на позначення годин і хвилин:  `09:00` або `21-30`.
 
-Write a regexp to find time:
+Напишіть регулярний вираз для пошуку часового формату:
 
 ```js
 let regexp = /your regexp/g;
-alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
+alert( "Сніданок о 09:00. Вечеря о 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-P.S. In this task we assume that the time is always correct, there's no need to filter out bad strings like "45:67". Later we'll deal with that too.
+P.S. В цій задачі ми завжди маємо коректний час, не потрібно перевіряти неіснуючі комбінації цифр, як-то "45:67". Пізніше ми роглянемо і такі випадки.

From fb140a895eef2117e609396f686d5a5859bc0526 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:47:52 +0200
Subject: [PATCH 16/24] Update solution.md

---
 .../1-find-range-1/solution.md                              | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index 85c7748f7..66bff8503 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -1,11 +1,11 @@
-Answers: **no, yes**.
+Відповідь: **ні, так**.
 
-- In the script `subject:Java` it doesn't match anything, because `pattern:[^script]` means "any character except given ones". So the regexp looks for `"Java"` followed by one such symbol, but there's a string end, no symbols after it.
+- В скрипті `subject:Java` немає співпадінь, оскільки `pattern:[^script]` означає "пошук будь-яких символів окрім заданих". Тож регулярний вираз шукає `"Java"` за яким слідує один такий символ, але це кінець рядку і далі немає символів.
 
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
     ```
-- Yes, because the `pattern:[^script]` part matches the character `"S"`. It's not one of `pattern:script`. As the regexp is case-sensitive (no `pattern:i` flag), it treats `"S"` as a different character from `"s"`.
+- Так, оскільки частина патерну `pattern:[^script]` співпадає з символом `"S"`. Його немає в переліку `pattern:script`. Оскільки регулярний вираз розрізняє регістри букв (не вказаний прапорець `pattern:i`), то для нього `"S"`та `"s"` це різні символи.
 
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"

From aded3d3b8edad6ba1039dda8ef404900397cfba8 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:48:34 +0200
Subject: [PATCH 17/24] Update task.md

---
 .../1-find-range-1/task.md                                    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
index 5a48e01e7..88d4d9781 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
@@ -1,5 +1,5 @@
 # Java[^script]
 
-We have a regexp `pattern:/Java[^script]/`.
+У нас є регулярний вираз  `pattern:/Java[^script]/`.
 
-Does it match anything in the string `subject:Java`? In the string `subject:JavaScript`?
+Чи знайде він співпадіння у рядку `subject:Java`? А у рядку `subject:JavaScript`?

From fb5e78b622c5ecc3f5be975648413f13c21d6a43 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:54:36 +0200
Subject: [PATCH 18/24] Update task.md

---
 .../09-regexp-quantifiers/1-find-text-manydots/task.md      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
index 4140b4a98..0ef9b4ee9 100644
--- a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-#  How to find an ellipsis "..." ?
+#  Як знайти розділовий знак три крапки "..." ?
 
-Create a regexp to find ellipsis: 3 (or more?) dots in a row.
+Створіть регулярний вираз, який знайде розділовий знак три крапки: 3 (чи навіть більше?) крапок у ряд.
 
-Check it:
+Перевірте:
 
 ```js
 let regexp = /your regexp/g;

From cf8bba9220366e73ef39c58911523924e959f1eb Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:57:35 +0200
Subject: [PATCH 19/24] Update solution.md

---
 .../09-regexp-quantifiers/1-find-text-manydots/solution.md  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
index 21b8762ec..7bf5f7574 100644
--- a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
+++ b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
@@ -1,9 +1,9 @@
 
-Solution:
+Відповідь:
 
 ```js run
 let regexp = /\.{3,}/g;
-alert( "Hello!... How goes?.....".match(regexp) ); // ..., .....
+alert( "Привіт!... Як справи?.....".match(regexp) ); // ..., .....
 ```
 
-Please note that the dot is a special character, so we have to escape it and insert as `\.`.
+Зауважте, що крапка це спец символ, тож потребує екранування за допомогою `\.`.

From a44dbbf7bf5bd4d7b012785cfc97d5be24760484 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 13:57:55 +0200
Subject: [PATCH 20/24] Update task.md

---
 .../09-regexp-quantifiers/1-find-text-manydots/task.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
index 0ef9b4ee9..c663d261b 100644
--- a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
@@ -10,5 +10,5 @@ importance: 5
 
 ```js
 let regexp = /your regexp/g;
-alert( "Hello!... How goes?.....".match(regexp) ); // ..., .....
+alert( "Привіт!... Як справи?.....".match(regexp) ); // ..., .....
 ```

From 67f9e710fb237d00a8a2aba85f39377533fc491d Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 14:01:10 +0200
Subject: [PATCH 21/24] Update task.md

---
 .../2-find-html-colors-6hex/task.md                    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
index 9a1923a7e..8bf9c4c44 100644
--- a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
+++ b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
@@ -1,15 +1,15 @@
-# Regexp for HTML colors
+# Регулярний вираз для кольорів в HTML
 
-Create a regexp to search HTML-colors written as `#ABCDEF`: first `#` and then 6 hexadecimal characters.
+Створіть регулярний вираз, який шукає HTML-кольори записані у форматі `#ABCDEF`: спершу символ `#` за яким слідують 6 шістнадцяткових символів.
 
-An example of use:
+Приклад використання:
 
 ```js
-let regexp = /...your regexp.../
+let regexp = /...ваш регулярний вираз.../
 
 let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2 #12345678";
 
 alert( str.match(regexp) )  // #121212,#AA00ef
 ```
 
-P.S. In this task we do not need other color formats like `#123` or `rgb(1,2,3)` etc.
+P.S. В цій задачі нам не потрібно враховувати інші формати запису кольорів, як наприклад `#123` або `rgb(1,2,3)` і т.д..

From 7f5a6e0a163236f7e482a8b264b672f4c0f4e7d9 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Mon, 19 Dec 2022 14:05:38 +0200
Subject: [PATCH 22/24] Update solution.md

---
 .../2-find-html-colors-6hex/solution.md         | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
index afee89c50..aff659e63 100644
--- a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
+++ b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
@@ -1,10 +1,10 @@
-We need to look for `#` followed by 6 hexadecimal characters.
+Нам потрбіно знайти символ `#` за яким слідують 6 шістнадцяткових символів.
 
-A hexadecimal character can be described as `pattern:[0-9a-fA-F]`. Or if we use the `pattern:i` flag, then just  `pattern:[0-9a-f]`.
+Шістнадцятковий символ можна описати як `pattern:[0-9a-fA-F]`. Або, якщо застосувати прапорець `pattern:i` , то запис скоротиться до `pattern:[0-9a-f]`.
 
-Then we can look for 6 of them using the quantifier `pattern:{6}`.
+Далі ми позначимо за допомогою квантифікатора, що нам потрібно саме 6 таких шістнадцяткових символів `pattern:{6}`.
 
-As a result, we have the regexp: `pattern:/#[a-f0-9]{6}/gi`.
+І у результаті, отримаємо такий регулярний вираз: `pattern:/#[a-f0-9]{6}/gi`.
 
 ```js run
 let regexp = /#[a-f0-9]{6}/gi;
@@ -14,18 +14,17 @@ let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2"
 alert( str.match(regexp) );  // #121212,#AA00ef
 ```
 
-The problem is that it finds the color in longer sequences:
-
+Проблема в тому, що вищевказаний регулярний вираз знаходитиме код кольору навіть у довших послідовностях.
 ```js run
 alert( "#12345678".match( /#[a-f0-9]{6}/gi ) ) // #123456
 ```
 
-To fix that, we can add `pattern:\b` to the end:
+Щоб виправити це, ми додамо `pattern:\b` на кінці виразу:
 
 ```js run
-// color
+// колір
 alert( "#123456".match( /#[a-f0-9]{6}\b/gi ) ); // #123456
 
-// not a color
+// не колір
 alert( "#12345678".match( /#[a-f0-9]{6}\b/gi ) ); // null
 ```

From f7c1581a1c55d7215196f7c0b1397826549be88b Mon Sep 17 00:00:00 2001
From: Stanislav <s.dolgachov@gmail.com>
Date: Wed, 4 Jan 2023 14:04:11 +0200
Subject: [PATCH 23/24] Apply suggestions from code review

---
 .../1-find-range-1/solution.md                                 | 2 +-
 .../2-find-time-2-formats/solution.md                          | 2 +-
 .../2-find-time-2-formats/task.md                              | 2 +-
 .../09-regexp-quantifiers/1-find-text-manydots/solution.md     | 2 +-
 .../09-regexp-quantifiers/1-find-text-manydots/task.md         | 2 +-
 .../09-regexp-quantifiers/2-find-html-colors-6hex/solution.md  | 3 ++-
 .../09-regexp-quantifiers/2-find-html-colors-6hex/task.md      | 2 +-
 7 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index 66bff8503..5d02d6e2c 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -5,7 +5,7 @@
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
     ```
-- Так, оскільки частина патерну `pattern:[^script]` співпадає з символом `"S"`. Його немає в переліку `pattern:script`. Оскільки регулярний вираз розрізняє регістри букв (не вказаний прапорець `pattern:i`), то для нього `"S"`та `"s"` це різні символи.
+- Так, оскільки частина патерну `pattern:[^script]` співпадає з символом `"S"`. Його немає в переліку `pattern:script`. Бо регулярний вираз розрізняє регістри букв (не вказаний прапорець `pattern:i`), то для нього `"S"`та `"s"` це різні символи.
 
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index d1e53155c..f93cce12f 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -5,4 +5,4 @@ let regexp = /\d\d[-:]\d\d/g;
 alert( "Сніданок о 09:00. Вечеря о 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-Зверніть увагу, що риска `pattern:'-'` має спеціальне значення у квартратних дужкахб але тільки між іншими символами, не на початку чи в кінці виразу, тож немає необхідності її екранувати.
+Зверніть увагу, що риска `pattern:'-'` має спеціальне значення у квадратних дужках але тільки між іншими символами, не на початку чи в кінці виразу, тож немає необхідності її екранувати.
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index 49ddd42ca..503f2c345 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -1,6 +1,6 @@
 # Знайдіть часовий формат hh:mm або hh-mm
 
-Час можна записати у форматі `години:хвилини` or `години-хвилини`. В будь-яку з варіантів потрібні дві цифри на позначення годин і хвилин:  `09:00` або `21-30`.
+Час можна записати у форматі `години:хвилини` або `години-хвилини`. У будь-якому разі потрібні дві цифри для позначення годин і хвилин:  `09:00` або `21-30`.
 
 Напишіть регулярний вираз для пошуку часового формату:
 
diff --git a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
index 7bf5f7574..bdbb48f16 100644
--- a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
+++ b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md
@@ -6,4 +6,4 @@ let regexp = /\.{3,}/g;
 alert( "Привіт!... Як справи?.....".match(regexp) ); // ..., .....
 ```
 
-Зауважте, що крапка це спец символ, тож потребує екранування за допомогою `\.`.
+Зауважте, що крапка це спецсимвол, тож потребує екранування за допомогою `\.`.
diff --git a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
index c663d261b..f2e32a839 100644
--- a/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 #  Як знайти розділовий знак три крапки "..." ?
 
-Створіть регулярний вираз, який знайде розділовий знак три крапки: 3 (чи навіть більше?) крапок у ряд.
+Створіть регулярний вираз, який знайде розділовий знак три крапки: 3 (чи навіть більше?) крапок поспіль.
 
 Перевірте:
 
diff --git a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
index aff659e63..5526a1896 100644
--- a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
+++ b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md
@@ -15,11 +15,12 @@ alert( str.match(regexp) );  // #121212,#AA00ef
 ```
 
 Проблема в тому, що вищевказаний регулярний вираз знаходитиме код кольору навіть у довших послідовностях.
+
 ```js run
 alert( "#12345678".match( /#[a-f0-9]{6}/gi ) ) // #123456
 ```
 
-Щоб виправити це, ми додамо `pattern:\b` на кінці виразу:
+Щоб виправити це, ми додамо `pattern:\b` у кінці виразу:
 
 ```js run
 // колір
diff --git a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
index 8bf9c4c44..d932c2984 100644
--- a/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
+++ b/9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md
@@ -12,4 +12,4 @@ let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2 #1234
 alert( str.match(regexp) )  // #121212,#AA00ef
 ```
 
-P.S. В цій задачі нам не потрібно враховувати інші формати запису кольорів, як наприклад `#123` або `rgb(1,2,3)` і т.д..
+P.S. В цій задачі нам не потрібно враховувати інші формати запису кольорів, як наприклад `#123` або `rgb(1,2,3)` тощо.

From 46430798eeb6ab0e7c603501008b765254440e01 Mon Sep 17 00:00:00 2001
From: Stanislav <s.dolgachov@gmail.com>
Date: Wed, 4 Jan 2023 14:05:57 +0200
Subject: [PATCH 24/24] Apply suggestions from code review

---
 .../article.md                                | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 303124a43..8db4b9b22 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -57,12 +57,12 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 
 - **\d** -- це те саме, що й `pattern:[0-9]`,
 - **\w** -- це те саме, що й `pattern:[a-zA-Z0-9_]`,
-- **\s** -- це те саме, що `pattern:[\t\n\v\f\r ]`, плюс деякілька інших рідких пробільних символів Unicode.
+- **\s** -- це те саме, що й `pattern:[\t\n\v\f\r ]`, плюс декілька інших рідкісних пробільних символів Unicode.
 ```
 
 ### Приклад: \w в інших мовах світу
 
-Оскільки символьний клас `pattern:\w` це лише скорочений запис `pattern:[a-zA-Z0-9_]`, він не зможе знайти китайські ієрогліфи, літери кирилицею і т.д.
+Оскільки символьний клас `pattern:\w` це лише скорочений запис `pattern:[a-zA-Z0-9_]`, він не зможе знайти китайські ієрогліфи, літери кирилицею тощо.
 
 Існує спосіб написати більш універсальний шаблон, що включатиме в себе буквенні символи будь-якої мови світу. Це легко реалізувати завдяки властивостям Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 
@@ -88,14 +88,14 @@ alert( str.match(regexp) ); // H,i,你,好,1,2
 Звичайно, ми можемо редагувати вищенаведений шаблон: додавати Unicode властивості, або видаляти їх. Дізнатись більше про Unicode властивості можна за посиланням <info:regexp-unicode>.
 
 ```warn header="Internet Explorer не підтримує Unicode властивості"
-Unicode властивості `pattern:p{…}` недоступні у Internet Explorer. ЯВтім, якщо вони нам все ж потрібні, ми можемо скористатись бібліотекою [XRegExp](http://xregexp.com/).
+Unicode властивості `pattern:p{…}` недоступні у Internet Explorer. Втім, якщо вони нам все ж потрібні, ми можемо скористатись бібліотекою [XRegExp](http://xregexp.com/).
 
-або просто вказати діапазон потрібних нам символів певною мовою, наприклад  `pattern:[а-я]` для літер кирилицею.
+або просто вказати діапазон потрібних нам символів певною мовою, наприклад `pattern:[а-я]` для літер кирилицею.
 ```
 
 ## Діапазони виключень
 
-Окрім звичайни діапазонів, існують діапазони "виключень" які виглядають наступним чином: `pattern:[^…]`.
+Окрім звичайних діапазонів, існують діапазони "виключень" які виглядають наступним чином: `pattern:[^…]`.
 
 Вони відрізняються символом каретки `^` на початку і знаходять будь-який символ *окрім вказаних в діапазоні*.
 
@@ -113,16 +113,16 @@ alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ та .
 
 ## Екранування всередині […]
 
-Зазвичай, коли ми хочемо знайти один зі спец символів, нам потрібно екранувати його наступним чином `pattern:\.`. Тобто, якщо нам потрібна зворотня коса риска, ми маємо писати `pattern:\\`, і  так далі.
+Зазвичай, коли ми хочемо знайти один зі спецсимволів, нам потрібно екранувати його наступним чином `pattern:\.`. Тобто, якщо нам потрібна зворотня коса риска, ми маємо писати `pattern:\\`, і  так далі.
 
-В квадратних дужках ми можемо використовувати велику кількість спец символів без екранування:
+В квадратних дужках ми можемо використовувати велику кількість спецсимволів без екранування:
 
 - Символ `pattern:. + ( )` не потребує екранування.
 - Дефіс `pattern:-` не потребує екранування на початку, або в кінці (тобто коли не може означати діапазон).
 - Каретка `pattern:^` екранується лише на початку (без екранування означає набір символів-виключень).
 - Закриваюча квадратна дужка `pattern:]` завжди потребує екранування (у випадках, коли нам потрібно знайти цей символ).
 
-Інакше кажучи, всі спец символи можна використовувати без екранування тоді, коли вони не мають додаткового значення в квадратних дужках.
+Інакше кажучи, всі спецсимволи можна використовувати без екранування тоді, коли вони не мають додаткового значення в квадратних дужках.
 
 Крапка `.` всередині квадратних дужок означає просто крапку. Шаблон `pattern:[.,]` шукатиме на один з двох символів, або крапку, або кому.
 
@@ -144,7 +144,7 @@ let regexp = /[\-\(\)\.\^\+]/g;
 alert( "1 + 2 - 3".match(regexp) ); // так само находить: +, -
 ```
 
-## Діапазони і прапор "u"
+## Діапазони і прапорець "u"
 
 Якщо в діапазоні є сурогатні пари, для коректної роботи регулярного виразу, прапорець `pattern:u` є обов'язковим.
 
@@ -155,7 +155,7 @@ alert( '𝒳'.match(/[𝒳𝒴]/) ); // виводить дивний симво
 // (пошук було виконано некореткно, повернуто тільки половину символу)
 ```
 
-Результат є некоректним, оскільки за замовчуванням регулярні вирази "не знають" про сурогатні пари.
+Результат є некоректним, оскільки типово регулярні вирази "не знають" про сурогатні пари.
 
 Регулярний вираз сприймає `[𝒳𝒴]` -- не як два, а як чотири символи:
 1. ліва половина `𝒳` `(1)`,