From fd901d25a678f0e3b6aaae8f6034469b9b8820d9 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 18:53:38 +0200
Subject: [PATCH 01/11] Update article.md

---
 .../14-regexp-lookahead-lookbehind/article.md | 124 +++++++++---------
 1 file changed, 62 insertions(+), 62 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index cee8215f9..e6c7f197f 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,134 +1,134 @@
-# Lookahead and lookbehind
+# Перегляд уперед та назад
 
-Sometimes we need to find only those matches for a pattern that are followed or preceded by another pattern.
+Іноді, нам потрібно знайти тільки такі співпадіння з шаблоном, за якими слідує, або яким передує інший шаблон.
 
-There's a special syntax for that, called "lookahead" and "lookbehind", together referred to as "lookaround".
+Для цього існують спеціальні синтаксичні конструкції, котрі називається "перегляд уперед" та "перегляд назад".
 
-For the start, let's find the price from the string like `subject:1 turkey costs 30€`. That is: a number, followed by `subject:€` sign.
+Для початку, давайте знайдемо ціну у рядку `subject:1 індичка коштує 30€`. Маємо: число, за яким йде символ `subject:€`.
 
-## Lookahead
+## Перегляд уперед
 
-The syntax is: `pattern:X(?=Y)`, it means "look for `pattern:X`, but match only if followed by `pattern:Y`". There may be any pattern instead of `pattern:X` and `pattern:Y`.
+Синтаксис виглядає наступнм чином: `pattern:X(?=Y)`, це означає "шукай `pattern:X`, але вважай його співпадінням, тільки якщо за ним слідує `pattern:Y`". Замість `pattern:X` та `pattern:Y` можуть бути будь-які інші шаблони.
 
-For an integer number followed by `subject:€`, the regexp will be `pattern:\d+(?=€)`:
+Для цілого числа, за яким слідує `subject:€`, регулярний вираз виглядатиме наступним чином `pattern:\d+(?=€)`:
 
 ```js run
-let str = "1 turkey costs 30€";
+let str = "1 індичка коштує 30€";
 
-alert( str.match(/\d+(?=€)/) ); // 30, the number 1 is ignored, as it's not followed by €
+alert( str.match(/\d+(?=€)/) ); // 30, число 1 ігнорується, оскільки після нього не стоїть символ €
 ```
 
-Please note: the lookahead is merely a test, the contents of the parentheses `pattern:(?=...)` is not included in the result `match:30`.
+Зверніть увагу: Перегляд уперед це свого роду тест, вміст в дужках `pattern:(?=...)` не входить до відображуваного регулярним виразом співпадіння `match:30`.
 
-When we look for `pattern:X(?=Y)`, the regular expression engine finds `pattern:X` and then checks if there's `pattern:Y` immediately after it. If it's not so, then the potential match is skipped, and the search continues.
+Коли ми шукаємо `pattern:X(?=Y)`, регулярний вираз знаходить `pattern:X` і далі перевіряє наявність `pattern:Y` одразу після нього. Якщо це не так, тоді потенційне співпадіння пропускається і регулярний вираз продовжує пошук.
 
-More complex tests are possible, e.g. `pattern:X(?=Y)(?=Z)` means:
+Можливі і більш складні тести, наприклад `pattern:X(?=Y)(?=Z)` означає:
 
-1. Find `pattern:X`.
-2. Check if `pattern:Y` is immediately after `pattern:X` (skip if isn't).
-3. Check if `pattern:Z` is also immediately after `pattern:X` (skip if isn't).
-4. If both tests passed, then the `pattern:X` is a match, otherwise continue searching.
+1. Знайди `pattern:X`.
+2. Перевір, чи `pattern:Y` йде одразу після `pattern:X` (пропускай, якщо це не так).
+3. Перевір, чи `pattern:Z` також йде одразу пысля `pattern:X` (пропускай, якщо це не так).
+4. Якщо обидва тести пройдено, тоді `pattern:X` відповідає умовам пошуку, в інщому випадку - продовжуй пошук.
 
-In other words, such pattern means that we're looking for `pattern:X` followed by `pattern:Y` and `pattern:Z` at the same time.
+Інакше кажучи, такий шаблон означає, що ми шукаємо на `pattern:X` за яким одночасно слідують `pattern:Y` та `pattern:Z`.
 
-That's only possible if patterns `pattern:Y` and `pattern:Z` aren't mutually exclusive.
+Це можливо тільки за умови, якщо шаблон `pattern:Y` та `pattern:Z` не взаємовиключні.
 
-For example, `pattern:\d+(?=\s)(?=.*30)` looks for `pattern:\d+` that is followed by a space `pattern:(?=\s)`, and there's `30` somewhere after it `pattern:(?=.*30)`:
+До прикладу, `pattern:\d+(?=\s)(?=.*30)` шукає на `pattern:\d+` за яким йде пробільний символ `pattern:(?=\s)`, а також `30` десь після нього `pattern:(?=.*30)`:
 
 ```js run
-let str = "1 turkey costs 30€";
+let str = "1 індичка коштує 30€";
 
 alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 ```
 
-In our string that exactly matches the number `1`.
+В нашому рядку цим параметрам повністю відповідає число `1`.
 
-## Negative lookahead
+## Негативний перегляд уперед
 
-Let's say that we want a quantity instead, not a price from the same string. That's a number `pattern:\d+`, NOT followed by `subject:€`.
+Скажімо, ми хочем знайти кількість, а не ціну в тому самому рядку. Тобто, шукаємо число `pattern:\d+`, за якийм НЕ слідує `subject:€`.
 
-For that, a negative lookahead can be applied.
+В такому випадку, доречним буде використання негативного перегляду уперед.
 
-The syntax is: `pattern:X(?!Y)`, it means "search `pattern:X`, but only if not followed by `pattern:Y`".
+Синатксис виглядає наступним чином: `pattern:X(?!Y)`, і означає "шукай `pattern:X`, але за умови, що після нього не йде `pattern:Y`".
 
 ```js run
-let str = "2 turkeys cost 60€";
+let str = "2 індички коштують 60€";
 
-alert( str.match(/\d+\b(?!€)/g) ); // 2 (the price is not matched)
+alert( str.match(/\d+\b(?!€)/g) ); // 2 (ціна не відповідає вимогам шаблону і не відображається в результаті)
 ```
 
-## Lookbehind
+## Перегляд назад
 
-```warn header="Lookbehind browser compatibility"
-Please Note: Lookbehind is not supported in non-V8 browsers, such as Safari, Internet Explorer.
+```warn header="Сумісність браузерів з переглядом назад"
+Зверніть увагу: Перегляд назад не підтримується в браузерах з відміннимим від V8 двигунами, зокрема Safari, Internet Explorer.
 ```
 
-Lookahead allows to add a condition for "what follows".
+Перегляд уперед дозволяє додати умову на кшталт "те, що слідує після".
 
-Lookbehind is similar, but it looks behind. That is, it allows to match a pattern only if there's something before it.
+Перегляд назад подібний, але дивиться у зворотньому напрямку. Таким чином, він виводить результат, тільки якщо співпадає і шаблон і те, що йде до нього.
 
-The syntax is:
-- Positive lookbehind: `pattern:(?<=Y)X`, matches `pattern:X`, but only if there's  `pattern:Y` before it.
-- Negative lookbehind: `pattern:(?<!Y)X`, matches `pattern:X`, but only if there's no `pattern:Y` before it.
+Синтаксис наступний:
+- Позитивний перегляд назад: `pattern:(?<=Y)X`, співпадає з `pattern:X`, тільки за умови, якщо перед ним є `pattern:Y`.
+- Негативний перегляд назад: `pattern:(?<!Y)X`, співпадає `pattern:X`, тільки за умови, якщо перед ним немає `pattern:Y`.
 
-For example, let's change the price to US dollars. The dollar sign is usually before the number, so to look for `$30` we'll use `pattern:(?<=\$)\d+` -- an amount preceded by `subject:$`:
+Наприклад, змінимо ціну з евро на американські долари. Знак долару зазвичай стоїть перед числом, тому, для пошуку `$30` ми використовуватимемо `pattern:(?<=\$)\d+` -- сума, перед якою є символ `subject:$`:
 
 ```js run
-let str = "1 turkey costs $30";
+let str = "1 індичка коштує $30";
 
-// the dollar sign is escaped \$
-alert( str.match(/(?<=\$)\d+/) ); // 30 (skipped the sole number)
+// знак долара екрановано \$
+alert( str.match(/(?<=\$)\d+/) ); // 30 (число 1 пропущено через відсутність знаку долару перед ним)
 ```
 
-And, if we need the quantity -- a number, not preceded by `subject:$`, then we can use a negative lookbehind `pattern:(?<!\$)\d+`:
+Також, якщо нам потрібна кількість -- число, якому не передує `subject:$`, в такому випадку ми можемо використати негативний перегляд назад `pattern:(?<!\$)\d+`:
 
 ```js run
-let str = "2 turkeys cost $60";
+let str = "2 індички коштують $60";
 
-alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (the price is not matched)
+alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (ціна не спвіпадає з умовами пошуку)
 ```
 
-## Capturing groups
+## Дужкові групи
 
-Generally, the contents inside lookaround parentheses does not become a part of the result.
+Зазвичай, вміст в дужках перегляду вперед та назад не є частиною співпадіння.
 
-E.g. in the pattern `pattern:\d+(?=€)`, the `pattern:€` sign doesn't get captured as a part of the match. That's natural: we look for a number `pattern:\d+`, while `pattern:(?=€)` is just a test that it should be followed by `subject:€`.
+Наприклад, у шаблоні `pattern:\d+(?=€)`, символ `pattern:€` не відображається при виведенні співпадінь. Це нормально: ми шукаємо на число `pattern:\d+`, тоді як `pattern:(?=€)` це лише перевірка на те, чи дійсно за ним йде символ `subject:€`.
 
-But in some situations we might want to capture the lookaround expression as well, or a part of it. That's possible. Just wrap that part into additional parentheses.
+Але в деяких ситуаціях ми можемо поребувати виведення вмісту шаблону перегляду вперед та назад, або його частини. Це можливо. Просто огорніть потрібну частину в додаткові круглі дужки.
 
-In the example below the currency sign `pattern:(€|kr)` is captured, along with the amount:
+В нижченаведеному прикладі знак валюти `pattern:(€|kr)` теж відображено у результаті, разом із сумою:
 
 ```js run
-let str = "1 turkey costs 30€";
-let regexp = /\d+(?=(€|kr))/; // extra parentheses around €|kr
+let str = "1 індичка коштує 30€";
+let regexp = /\d+(?=(€|kr))/; // додаткові круглі дужки навколо €|kr
 
 alert( str.match(regexp) ); // 30, €
 ```
 
-And here's the same for lookbehind:
+І так само для перегляду назад:
 
 ```js run
-let str = "1 turkey costs $30";
+let str = "1 індичка коштує $30";
 let regexp = /(?<=(\$|£))\d+/;
 
 alert( str.match(regexp) ); // 30, $
 ```
 
-## Summary
+## Підсумок
 
-Lookahead and lookbehind (commonly referred to as "lookaround") are useful when we'd like to match something depending on the context before/after it.
+Перегляд вперед на назад корисні, коли нам потрібно знайти щось, залежно від контексту до чи після потрібного шаблону.
 
-For simple regexps we can do the similar thing manually. That is: match everything, in any context, and then filter by context in the loop.
+Для простих регулярних виразів ми можемо виконати подібну задачу вручну. Тобто: відшукати всі спвіпадіння, у будь-якому контексті, а потім відфільтрувати їх за контекстом за допомогою циклу.
 
-Remember, `str.match` (without flag `pattern:g`) and `str.matchAll` (always) return matches as arrays with `index` property, so we know where exactly in the text it is, and can check the context.
+Пам'ятайте, `str.match` (без флажку `pattern:g`) і `str.matchAll` (всі) повертає співпадіння у вигляді масиву з властивістю `індекс`, тож ми точно знаємо де саме в тексті вони знаходяться і можемо перевірити контекст.
 
-But generally lookaround is more convenient.
+Але загалом перегляд уперед і назад більш підходящі.
 
-Lookaround types:
+Типи переглядів:
 
-| Pattern            | type             | matches |
+| Шаблон            | Тип             | Співпадіння |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Positive lookahead | `pattern:X` if followed by `pattern:Y` |
-| `X(?!Y)`   | Negative lookahead | `pattern:X` if not followed by `pattern:Y` |
-| `(?<=Y)X` |  Positive lookbehind | `pattern:X` if after `pattern:Y` |
-| `(?<!Y)X` | Negative lookbehind | `pattern:X` if not after `pattern:Y` |
+| `X(?=Y)`   | Позитивний перегляд уперед | `pattern:X` якщо за ним йде `pattern:Y` |
+| `X(?!Y)`   | Негативний перегляд уперед | `pattern:X` якщо за ним не йде `pattern:Y` |
+| `(?<=Y)X` |  Позитивний перегляд назад  | `pattern:X` якщо він йде після `pattern:Y` |
+| `(?<!Y)X` | Негативний перегляд назад | `pattern:X` якщо тільки він не йде після `pattern:Y` |

From 214ce9965074e78c3f6e1141beb2c9cb774a9209 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 18:59:14 +0200
Subject: [PATCH 02/11] Update solution.md

---
 .../1-find-non-negative-integers/solution.md        | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
index ebc12689d..b7e4eb40d 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
@@ -1,9 +1,8 @@
+Регулярний вираз для цілого числа `pattern:\d+`.
 
-The regexp for an integer number is `pattern:\d+`.
+Ми можемо виключити від'ємні числа попередньо написавши регулярний вираз для негативного перегляду назад: `pattern:(?<!-)\d+`.
 
-We can exclude negatives by prepending it with the negative lookbehind: `pattern:(?<!-)\d+`.
-
-Although, if we try it now, we may notice one more "extra" result:
+Хоча, випробувавши його, ми побачимо одне "екстра" співпадіння:
 
 ```js run
 let regexp = /(?<!-)\d+/g;
@@ -13,11 +12,11 @@ let str = "0 12 -5 123 -18";
 console.log( str.match(regexp) ); // 0, 12, 123, *!*8*/!*
 ```
 
-As you can see, it matches `match:8`, from `subject:-18`. To exclude it, we need to ensure that the regexp starts matching a number not from the middle of another (non-matching) number.
+Як ви бачите, шаблон знаходить `match:8`, у `subject:-18`. Щоб виключит і його, нам необхідно переконатись, що регулярний вираз починає пошук не з середини іншого не піходящого числа.
 
-We can do it by specifying another negative lookbehind: `pattern:(?<!-)(?<!\d)\d+`. Now `pattern:(?<!\d)` ensures that a match does not start after another digit, just what we need.
+Ми можемо це реалізувати вказавши додатковий вираз для негативного перегляду назад: `pattern:(?<!-)(?<!\d)\d+`. Зараз `pattern:(?<!\d)` перевіряє, щоб пошук не починався одразу після іншого числа, як нам і було потрібно.
 
-We can also join them into a single lookbehind here:
+Ми можемо об'єднати вирази в один таким чином:
 
 ```js run
 let regexp = /(?<![-\d])\d+/g;

From 2a6c660cb4d84fb988805768be07b6297228dd90 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:01:11 +0200
Subject: [PATCH 03/11] Update task.md

---
 .../1-find-non-negative-integers/task.md               | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
index cd58f9923..85ec5c752 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
@@ -1,12 +1,12 @@
-# Find non-negative integers
+# Знайдіть цілі невід'ємні числа
 
-There's a string of integer numbers.
+Дано рядок з цілих чисел.
 
-Create a regexp that looks for only non-negative ones (zero is allowed).
+Напишіть регулярний вираз, який знаходить тільки цілі невід'ємні числа (нуль допускається).
 
-An example of use:
+Приклад використання:
 ```js
-let regexp = /your regexp/g;
+let regexp = /ваш регулярний вираз/g;
 
 let str = "0 12 -5 123 -18";
 

From b72a0225e486b129c44551f71a7bb0e14f43a656 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:01:33 +0200
Subject: [PATCH 04/11] Update solution.md

---
 .../1-find-non-negative-integers/solution.md                    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
index b7e4eb40d..fe67ab4aa 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
@@ -2,7 +2,7 @@
 
 Ми можемо виключити від'ємні числа попередньо написавши регулярний вираз для негативного перегляду назад: `pattern:(?<!-)\d+`.
 
-Хоча, випробувавши його, ми побачимо одне "екстра" співпадіння:
+Хоча, випробувавши його, ми побачимо одне зайве співпадіння:
 
 ```js run
 let regexp = /(?<!-)\d+/g;

From e43cb3b27154769dd5b9410bcdc83338c0116fd5 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:04:06 +0200
Subject: [PATCH 05/11] Update task.md

---
 .../2-insert-after-head/task.md                  | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
index be1a259f6..8e2ab6b47 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
@@ -1,13 +1,13 @@
-# Insert After Head
+# Додайте після тегу Head
 
-We have a string with an HTML Document.
+У нас є рядок з HTML-документом.
 
-Write a regular expression that inserts `<h1>Hello</h1>` immediately after `<body>` tag. The tag may have attributes.
+Напишіть регулярний вираз який вставляє `<h1>Привіт</h1>` одразу після тегу `<body>`. Тег може мати атрибути.
 
-For instance:
+Приклад:
 
 ```js
-let regexp = /your regular expression/;
+let regexp = /ваш регулярний вираз/;
 
 let str = `
 <html>
@@ -17,13 +17,13 @@ let str = `
 </html>
 `;
 
-str = str.replace(regexp, `<h1>Hello</h1>`);
+str = str.replace(regexp, `<h1>Привіт</h1>`);
 ```
 
-After that the value of `str` should be:
+Після цього значення `str` має бути:
 ```html
 <html>
-  <body style="height: 200px"><h1>Hello</h1>
+  <body style="height: 200px"><h1>Привіт</h1>
   ...
   </body>
 </html>

From f8102837f04b77c812a006bd881d6972b85e8943 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:08:44 +0200
Subject: [PATCH 06/11] Update solution.md

---
 .../2-insert-after-head/solution.md           | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
index b1d377d33..940a2296e 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
@@ -1,28 +1,28 @@
-In order to insert after the `<body>` tag, we must first find it. We can use the regular expression pattern `pattern:<body.*?>` for that.
+Щоб додати інформацію після тегу `<body>` , нам потрібно спершу його знайти. Ми можемо використати для цього шаблон регулярного виразу `pattern:<body.*?>`.
 
-In this task we don't need to modify the `<body>` tag. We only need to add the text after it.
+в цьому завданні нам не потрібно змінювати тег `<body>`. Нам потрібно тільки додати текст після нього.
 
-Here's how we can do it:
+Ось таким чином ми можемо це зробити:
 
 ```js run
 let str = '...<body style="...">...';
-str = str.replace(/<body.*?>/, '$&<h1>Hello</h1>');
+str = str.replace(/<body.*?>/, '$&<h1>Привіт</h1>');
 
-alert(str); // ...<body style="..."><h1>Hello</h1>...
+alert(str); // ...<body style="..."><h1>Привіт</h1>...
 ```
 
-In the replacement string `$&` means the match itself, that is, the part of the source text that corresponds to `pattern:<body.*?>`. It gets replaced by itself plus `<h1>Hello</h1>`.
+в заміненому рядку `$&` означає співпадіння саме по собі, тобто, частина вихідного тексту яка відповідає шаблону `pattern:<body.*?>`. Її замінено на неї ж плюс `<h1>Привіт</h1>`.
 
-An alternative is to use lookbehind:
+Альнернативою було би використання перегляду назад:
 
 ```js run
 let str = '...<body style="...">...';
-str = str.replace(/(?<=<body.*?>)/, `<h1>Hello</h1>`);
+str = str.replace(/(?<=<body.*?>)/, `<h1>Привіт</h1>`);
 
-alert(str); // ...<body style="..."><h1>Hello</h1>...
+alert(str); // ...<body style="..."><h1>привіт</h1>...
 ```
 
-As you can see, there's only lookbehind part in this regexp.
+Як бачите, є тільки перегляд назад у цьому регулярному виразі.
 
 It works like this:
 - At every position in the text.

From 1cbe619629189f753a79cc6edca01b665517a42e Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:13:23 +0200
Subject: [PATCH 07/11] Update task.md

---
 .../1-find-non-negative-integers/task.md                         | 1 +
 1 file changed, 1 insertion(+)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
index 85ec5c752..1b0cc33ce 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
@@ -1,3 +1,4 @@
+
 # Знайдіть цілі невід'ємні числа
 
 Дано рядок з цілих чисел.

From 0587094711b2b17d659663731bdc7a927b4d953c Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:13:59 +0200
Subject: [PATCH 08/11] Update task.md

---
 .../1-find-non-negative-integers/task.md                         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
index 1b0cc33ce..85ec5c752 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
@@ -1,4 +1,3 @@
-
 # Знайдіть цілі невід'ємні числа
 
 Дано рядок з цілих чисел.

From 6d90c0ff20d93450f1d9847788aa3e2f71d7d681 Mon Sep 17 00:00:00 2001
From: Mariana Melnychenko <110090508+MrsMelnychenko@users.noreply.github.com>
Date: Fri, 6 Jan 2023 19:14:42 +0200
Subject: [PATCH 09/11] Update solution.md

---
 .../1-find-non-negative-integers/solution.md                     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
index fe67ab4aa..20ef9543c 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
@@ -1,3 +1,4 @@
+
 Регулярний вираз для цілого числа `pattern:\d+`.
 
 Ми можемо виключити від'ємні числа попередньо написавши регулярний вираз для негативного перегляду назад: `pattern:(?<!-)\d+`.

From e239faab11766cd6565686770364e35cba7f2017 Mon Sep 17 00:00:00 2001
From: Stanislav <s.dolgachov@gmail.com>
Date: Sun, 12 Mar 2023 21:28:37 +0200
Subject: [PATCH 10/11] Apply suggestions from code review

---
 .../1-find-non-negative-integers/solution.md  |  8 +--
 .../1-find-non-negative-integers/task.md      |  2 +-
 .../2-insert-after-head/solution.md           | 10 +--
 .../2-insert-after-head/task.md               |  2 +-
 .../14-regexp-lookahead-lookbehind/article.md | 62 +++++++++----------
 5 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
index 20ef9543c..1c9408c67 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
@@ -1,7 +1,7 @@
 
 Регулярний вираз для цілого числа `pattern:\d+`.
 
-Ми можемо виключити від'ємні числа попередньо написавши регулярний вираз для негативного перегляду назад: `pattern:(?<!-)\d+`.
+Ми можемо виключити від'ємні числа попередньо написавши регулярний вираз для негативної зворотньої перевірки: `pattern:(?<!-)\d+`.
 
 Хоча, випробувавши його, ми побачимо одне зайве співпадіння:
 
@@ -13,11 +13,11 @@ let str = "0 12 -5 123 -18";
 console.log( str.match(regexp) ); // 0, 12, 123, *!*8*/!*
 ```
 
-Як ви бачите, шаблон знаходить `match:8`, у `subject:-18`. Щоб виключит і його, нам необхідно переконатись, що регулярний вираз починає пошук не з середини іншого не піходящого числа.
+Як ви бачите, шаблон знаходить `match:8`, у `subject:-18`. Щоб виключити і його, нам необхідно переконатись, що регулярний вираз починає пошук не з середини іншого числа, яке не підходить.
 
-Ми можемо це реалізувати вказавши додатковий вираз для негативного перегляду назад: `pattern:(?<!-)(?<!\d)\d+`. Зараз `pattern:(?<!\d)` перевіряє, щоб пошук не починався одразу після іншого числа, як нам і було потрібно.
+Ми можемо це реалізувати вказавши додатковий вираз для негативної зворотньої перевірки: `pattern:(?<!-)(?<!\d)\d+`. Зараз `pattern:(?<!\d)` перевіряє, щоб пошук не починався одразу після іншого числа, як нам і було потрібно.
 
-Ми можемо об'єднати вирази в один таким чином:
+Ми можемо об'єднати їх в один таким чином:
 
 ```js run
 let regexp = /(?<![-\d])\d+/g;
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
index 85ec5c752..9316f5fac 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
@@ -1,6 +1,6 @@
 # Знайдіть цілі невід'ємні числа
 
-Дано рядок з цілих чисел.
+Є рядок з цілих чисел.
 
 Напишіть регулярний вираз, який знаходить тільки цілі невід'ємні числа (нуль допускається).
 
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
index 940a2296e..6e922159d 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
@@ -1,4 +1,4 @@
-Щоб додати інформацію після тегу `<body>` , нам потрібно спершу його знайти. Ми можемо використати для цього шаблон регулярного виразу `pattern:<body.*?>`.
+Щоб вставити після тегу `<body>` , нам потрібно спершу його знайти. Ми можемо використати для цього регулярний вираз `pattern:<body.*?>`.
 
 в цьому завданні нам не потрібно змінювати тег `<body>`. Нам потрібно тільки додати текст після нього.
 
@@ -13,19 +13,19 @@ alert(str); // ...<body style="..."><h1>Привіт</h1>...
 
 в заміненому рядку `$&` означає співпадіння саме по собі, тобто, частина вихідного тексту яка відповідає шаблону `pattern:<body.*?>`. Її замінено на неї ж плюс `<h1>Привіт</h1>`.
 
-Альнернативою було би використання перегляду назад:
+Альнернативою було би використання зворотньої перевірки:
 
 ```js run
 let str = '...<body style="...">...';
 str = str.replace(/(?<=<body.*?>)/, `<h1>Привіт</h1>`);
 
-alert(str); // ...<body style="..."><h1>привіт</h1>...
+alert(str); // ...<body style="..."><h1>Привіт</h1>...
 ```
 
 Як бачите, є тільки перегляд назад у цьому регулярному виразі.
 
-It works like this:
-- At every position in the text.
+Це працює таким чином:
+- На кожній позиції в тексті.
 - Check if it's preceeded by `pattern:<body.*?>`.
 - If it's so then we have the match.
 
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
index 8e2ab6b47..05b42daf7 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
@@ -1,4 +1,4 @@
-# Додайте після тегу Head
+# Вставка після Head
 
 У нас є рядок з HTML-документом.
 
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index e6c7f197f..98b8604d2 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,12 +1,12 @@
-# Перегляд уперед та назад
+# Перевірка уперед та назад
 
 Іноді, нам потрібно знайти тільки такі співпадіння з шаблоном, за якими слідує, або яким передує інший шаблон.
 
-Для цього існують спеціальні синтаксичні конструкції, котрі називається "перегляд уперед" та "перегляд назад".
+Для цього існують спеціальні синтаксичні конструкції, котрі називається "перевірка уперед" та "перевірка назад".
 
 Для початку, давайте знайдемо ціну у рядку `subject:1 індичка коштує 30€`. Маємо: число, за яким йде символ `subject:€`.
 
-## Перегляд уперед
+## Перевірка уперед
 
 Синтаксис виглядає наступнм чином: `pattern:X(?=Y)`, це означає "шукай `pattern:X`, але вважай його співпадінням, тільки якщо за ним слідує `pattern:Y`". Замість `pattern:X` та `pattern:Y` можуть бути будь-які інші шаблони.
 
@@ -18,7 +18,7 @@ let str = "1 індичка коштує 30€";
 alert( str.match(/\d+(?=€)/) ); // 30, число 1 ігнорується, оскільки після нього не стоїть символ €
 ```
 
-Зверніть увагу: Перегляд уперед це свого роду тест, вміст в дужках `pattern:(?=...)` не входить до відображуваного регулярним виразом співпадіння `match:30`.
+Зверніть увагу: перевірка уперед це свого роду тест, вміст в дужках `pattern:(?=...)` не входить до відображуваного регулярним виразом співпадіння `match:30`.
 
 Коли ми шукаємо `pattern:X(?=Y)`, регулярний вираз знаходить `pattern:X` і далі перевіряє наявність `pattern:Y` одразу після нього. Якщо це не так, тоді потенційне співпадіння пропускається і регулярний вираз продовжує пошук.
 
@@ -26,14 +26,14 @@ alert( str.match(/\d+(?=€)/) ); // 30, число 1 ігнорується, о
 
 1. Знайди `pattern:X`.
 2. Перевір, чи `pattern:Y` йде одразу після `pattern:X` (пропускай, якщо це не так).
-3. Перевір, чи `pattern:Z` також йде одразу пысля `pattern:X` (пропускай, якщо це не так).
-4. Якщо обидва тести пройдено, тоді `pattern:X` відповідає умовам пошуку, в інщому випадку - продовжуй пошук.
+3. Перевір, чи `pattern:Z` також йде одразу після `pattern:X` (пропускай, якщо це не так).
+4. Якщо обидва тести пройдено, тоді `pattern:X` відповідає умовам пошуку, в інщому випадку -- продовжуй пошук.
 
 Інакше кажучи, такий шаблон означає, що ми шукаємо на `pattern:X` за яким одночасно слідують `pattern:Y` та `pattern:Z`.
 
-Це можливо тільки за умови, якщо шаблон `pattern:Y` та `pattern:Z` не взаємовиключні.
+Це можливо тільки за умови, якщо шаблон `pattern:Y` та `pattern:Z` не виключають один одного.
 
-До прикладу, `pattern:\d+(?=\s)(?=.*30)` шукає на `pattern:\d+` за яким йде пробільний символ `pattern:(?=\s)`, а також `30` десь після нього `pattern:(?=.*30)`:
+Наприклад, `pattern:\d+(?=\s)(?=.*30)` шукає на `pattern:\d+` за яким йде пробільний символ `pattern:(?=\s)`, а також `30` десь після нього `pattern:(?=.*30)`:
 
 ```js run
 let str = "1 індичка коштує 30€";
@@ -43,13 +43,13 @@ alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 
 В нашому рядку цим параметрам повністю відповідає число `1`.
 
-## Негативний перегляд уперед
+## Негативна перевірка уперед
 
 Скажімо, ми хочем знайти кількість, а не ціну в тому самому рядку. Тобто, шукаємо число `pattern:\d+`, за якийм НЕ слідує `subject:€`.
 
 В такому випадку, доречним буде використання негативного перегляду уперед.
 
-Синатксис виглядає наступним чином: `pattern:X(?!Y)`, і означає "шукай `pattern:X`, але за умови, що після нього не йде `pattern:Y`".
+Синтаксис виглядає наступним чином: `pattern:X(?!Y)`, і означає "шукай `pattern:X`, але за умови, що після нього не йде `pattern:Y`".
 
 ```js run
 let str = "2 індички коштують 60€";
@@ -57,21 +57,21 @@ let str = "2 індички коштують 60€";
 alert( str.match(/\d+\b(?!€)/g) ); // 2 (ціна не відповідає вимогам шаблону і не відображається в результаті)
 ```
 
-## Перегляд назад
+## Перевірка назад
 
-```warn header="Сумісність браузерів з переглядом назад"
-Зверніть увагу: Перегляд назад не підтримується в браузерах з відміннимим від V8 двигунами, зокрема Safari, Internet Explorer.
+```warn header="Сумісність браузерів з перевіркою назад"
+Зверніть увагу: Перевірка назад не підтримується в браузерах з відміннимим від V8 двигунами, зокрема Safari, Internet Explorer.
 ```
 
-Перегляд уперед дозволяє додати умову на кшталт "те, що слідує після".
+Перевірка уперед дозволяє додати умову на кшталт "те, що слідує після".
 
-Перегляд назад подібний, але дивиться у зворотньому напрямку. Таким чином, він виводить результат, тільки якщо співпадає і шаблон і те, що йде до нього.
+Перевірка назад подібна, але дивиться у зворотньому напрямку. Таким чином, вона видає результат, тільки якщо співпадає і шаблон і те, що йде до нього.
 
 Синтаксис наступний:
-- Позитивний перегляд назад: `pattern:(?<=Y)X`, співпадає з `pattern:X`, тільки за умови, якщо перед ним є `pattern:Y`.
-- Негативний перегляд назад: `pattern:(?<!Y)X`, співпадає `pattern:X`, тільки за умови, якщо перед ним немає `pattern:Y`.
+- Позитивна перевірка назад: `pattern:(?<=Y)X`, співпадає з `pattern:X`, тільки за умови, якщо перед ним є `pattern:Y`.
+- Негативна перевірка назад: `pattern:(?<!Y)X`, співпадає `pattern:X`, тільки за умови, якщо перед ним немає `pattern:Y`.
 
-Наприклад, змінимо ціну з евро на американські долари. Знак долару зазвичай стоїть перед числом, тому, для пошуку `$30` ми використовуватимемо `pattern:(?<=\$)\d+` -- сума, перед якою є символ `subject:$`:
+Наприклад, змінимо ціну з євро на американські долари. Знак долару зазвичай стоїть перед числом, тому, для пошуку `$30` ми використовуватимемо `pattern:(?<=\$)\d+` -- сума, перед якою є символ `subject:$`:
 
 ```js run
 let str = "1 індичка коштує $30";
@@ -80,21 +80,21 @@ let str = "1 індичка коштує $30";
 alert( str.match(/(?<=\$)\d+/) ); // 30 (число 1 пропущено через відсутність знаку долару перед ним)
 ```
 
-Також, якщо нам потрібна кількість -- число, якому не передує `subject:$`, в такому випадку ми можемо використати негативний перегляд назад `pattern:(?<!\$)\d+`:
+Також, якщо нам потрібна кількість -- число, якому не передує `subject:$`, в такому випадку ми можемо використати негативну перевірку назад `pattern:(?<!\$)\d+`:
 
 ```js run
 let str = "2 індички коштують $60";
 
-alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (ціна не спвіпадає з умовами пошуку)
+alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (ціна не співпадає з умовами пошуку)
 ```
 
 ## Дужкові групи
 
-Зазвичай, вміст в дужках перегляду вперед та назад не є частиною співпадіння.
+Зазвичай, в регулярних виразах вміст в дужках не є частиною співпадіння.
 
 Наприклад, у шаблоні `pattern:\d+(?=€)`, символ `pattern:€` не відображається при виведенні співпадінь. Це нормально: ми шукаємо на число `pattern:\d+`, тоді як `pattern:(?=€)` це лише перевірка на те, чи дійсно за ним йде символ `subject:€`.
 
-Але в деяких ситуаціях ми можемо поребувати виведення вмісту шаблону перегляду вперед та назад, або його частини. Це можливо. Просто огорніть потрібну частину в додаткові круглі дужки.
+Але в деяких ситуаціях ми можемо також потребувати виведення вмісту цього шаблону або його частини. Це можливо. Просто огорніть потрібну частину в додаткові круглі дужки.
 
 В нижченаведеному прикладі знак валюти `pattern:(€|kr)` теж відображено у результаті, разом із сумою:
 
@@ -114,21 +114,21 @@ let regexp = /(?<=(\$|£))\d+/;
 alert( str.match(regexp) ); // 30, $
 ```
 
-## Підсумок
+## Підсумки
 
-Перегляд вперед на назад корисні, коли нам потрібно знайти щось, залежно від контексту до чи після потрібного шаблону.
+Перевірка уперед та назад корисні, коли нам потрібно знайти щось, залежно від контексту до чи після потрібного шаблону.
 
-Для простих регулярних виразів ми можемо виконати подібну задачу вручну. Тобто: відшукати всі спвіпадіння, у будь-якому контексті, а потім відфільтрувати їх за контекстом за допомогою циклу.
+Для простих регулярних виразів ми можемо виконати подібну задачу вручну. Тобто: відшукати всі співпадіння, у будь-якому контексті, а потім відфільтрувати їх за контекстом за допомогою циклу.
 
-Пам'ятайте, `str.match` (без флажку `pattern:g`) і `str.matchAll` (всі) повертає співпадіння у вигляді масиву з властивістю `індекс`, тож ми точно знаємо де саме в тексті вони знаходяться і можемо перевірити контекст.
+Пам'ятайте, `str.match` (без прапорцю `pattern:g`) і `str.matchAll` (завжди) повертає співпадіння у вигляді масиву з властивістю `index`, тож ми точно знаємо де саме в тексті вони знаходяться і можемо перевірити контекст.
 
-Але загалом перегляд уперед і назад більш підходящі.
+Але загалом перевірка уперед і назад більш підходящі.
 
 Типи переглядів:
 
 | Шаблон            | Тип             | Співпадіння |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Позитивний перегляд уперед | `pattern:X` якщо за ним йде `pattern:Y` |
-| `X(?!Y)`   | Негативний перегляд уперед | `pattern:X` якщо за ним не йде `pattern:Y` |
-| `(?<=Y)X` |  Позитивний перегляд назад  | `pattern:X` якщо він йде після `pattern:Y` |
-| `(?<!Y)X` | Негативний перегляд назад | `pattern:X` якщо тільки він не йде після `pattern:Y` |
+| `X(?=Y)`   | Позитивна перевірка уперед | `pattern:X` якщо за ним йде `pattern:Y` |
+| `X(?!Y)`   | Негативна перевірка уперед | `pattern:X` якщо за ним не йде `pattern:Y` |
+| `(?<=Y)X` |  Позитивна перевірка назад  | `pattern:X` якщо він йде після `pattern:Y` |
+| `(?<!Y)X` | Негативна перевірка назад | `pattern:X` якщо тільки він не йде після `pattern:Y` |

From 084e6f0e086f6e941a401084f3044bdb8af85353 Mon Sep 17 00:00:00 2001
From: Stanislav <s.dolgachov@gmail.com>
Date: Sun, 12 Mar 2023 21:29:21 +0200
Subject: [PATCH 11/11] Apply suggestions from code review

---
 .../2-insert-after-head/solution.md                             | 2 +-
 9-regular-expressions/14-regexp-lookahead-lookbehind/article.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
index 6e922159d..108d5f78b 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
@@ -22,7 +22,7 @@ str = str.replace(/(?<=<body.*?>)/, `<h1>Привіт</h1>`);
 alert(str); // ...<body style="..."><h1>Привіт</h1>...
 ```
 
-Як бачите, є тільки перегляд назад у цьому регулярному виразі.
+Як бачите, в цьому регулярному виразі є тільки зворотня перевірка.
 
 Це працює таким чином:
 - На кожній позиції в тексті.
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 98b8604d2..d6dd00cfe 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -47,7 +47,7 @@ alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 
 Скажімо, ми хочем знайти кількість, а не ціну в тому самому рядку. Тобто, шукаємо число `pattern:\d+`, за якийм НЕ слідує `subject:€`.
 
-В такому випадку, доречним буде використання негативного перегляду уперед.
+В такому випадку, доречним буде використання негативної перевірки уперед.
 
 Синтаксис виглядає наступним чином: `pattern:X(?!Y)`, і означає "шукай `pattern:X`, але за умови, що після нього не йде `pattern:Y`".