From a807951f84ea89e92e7d2c6a2ed39ec29ab2a03b Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sat, 18 May 2019 17:27:55 +0300
Subject: [PATCH 01/15] 02-bubbling-and-capturing: Translate the first part

---
 .../02-bubbling-and-capturing/article.md      | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index bae476f7ef..17b0070a63 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -1,24 +1,24 @@
-# Bubbling and capturing
+# Всплытие и перехват
 
-Let's start with an example.
+Давайте начнём с примера.
 
-This handler is assigned to `<div>`, but also runs if you click any nested tag like `<em>` or `<code>`:
+Этот обработчик для `<div>` сработает, если вы кликните по вложенному тегу `<em>` или `<code>`:
 
 ```html autorun height=60
-<div onclick="alert('The handler!')">
-  <em>If you click on <code>EM</code>, the handler on <code>DIV</code> runs.</em>
+<div onclick="alert('Обработчик!')">
+  <em>Если вы кликните на <code>EM</code>, сработает обработчик на <code>DIV</code></em>
 </div>
 ```
 
-Isn't it a bit strange? Why does the handler on `<div>` run if the actual click was on `<em>`?
+Вам не кажется это странным? Почему же сработал обработчик на `<div>`, если клик произошёл на `<em>`?
 
-## Bubbling
+## Всплытие
 
-The bubbling principle is simple.
+Принцип всплытия очень простой.
 
-**When an event happens on an element, it first runs the handlers on it, then on its parent, then all the way up on other ancestors.**
+**Когда на элементе происходит событие, обработчики сначала срабатывают на нём, потом на его родителе, затем выше и так далее, вверх по цепочке вложенности.**
 
-Let's say we have 3 nested elements `FORM > DIV > P` with a handler on each of them:
+Например, есть 3 вложенных элемента `FORM > DIV > P`, с обработчиком на каждом:
 
 ```html run autorun
 <style>
@@ -35,22 +35,22 @@ Let's say we have 3 nested elements `FORM > DIV > P` with a handler on each of t
 </form>
 ```
 
-A click on the inner `<p>` first runs `onclick`:
-1. On that `<p>`.
-2. Then on the outer `<div>`.
-3. Then on the outer `<form>`.
-4. And so on upwards till the `document` object.
+Клик по внутреннему `<p>` вызовет обработчик `onclick`:
+1. Сначала на самом `<p>`.
+2. Потом на внешнем `<div>`.
+3. Затем на внешнем `<form>`.
+4. И так далее вверх по цепочке до самого `document`.
 
 ![](event-order-bubbling.png)
 
-So if we click on `<p>`, then we'll see 3 alerts: `p` -> `div` -> `form`.
+Поэтому если кликнуть на `<p>`, то мы увидим три оповещения: `p` -> `div` -> `form`.
 
-The process is called "bubbling", because events "bubble" from the inner element up through parents like a bubble in the water.
+Этот процесс называется "всплытием", потому что события "всплывают" от внутреннего элемента вверх через родителей, подобно тому, как всплывает пузырек воздуха в воде.
 
-```warn header="*Almost* all events bubble."
-The key word in this phrase is "almost".
+```warn header="*Почти* все события всплывают."
+Ключевое слово в этой фразе -- "почти".
 
-For instance, a `focus` event does not bubble. There are other examples too, we'll meet them. But still it's an exception, rather than a rule, most events do bubble.
+Например, событие `focus` не всплывает. В дальнейшем мы увидим и другие примеры. Однако, стоит понимать, что это скорее исключение, чем правило, всё-таки большинство событий всплывают.
 ```
 
 ## event.target

From ff58a1d35ebd8e256c3cb204f947b4510da50c9d Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 19 May 2019 16:58:08 +0300
Subject: [PATCH 02/15] 02-bubbling-and-capturing: Translate all about bubbling

---
 .../02-bubbling-and-capturing/article.md      | 58 +++++++++----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 17b0070a63..621d6b3a44 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -55,64 +55,64 @@
 
 ## event.target
 
-A handler on a parent element can always get the details about where it actually happened.
+Всегда можно узнать, на каком конкретно элементе произошло событие.
 
-**The most deeply nested element that caused the event is called a *target* element, accessible as `event.target`.**
+**Самый глубокий элемент, который вызывает событие, называется *исходным* элементом, и он доступен через `event.target`.**
 
-Note the differences from `this` (=`event.currentTarget`):
+Отличия от `this` (=`event.currentTarget`):
 
-- `event.target` -- is the "target" element that initiated the event, it doesn't change through the bubbling process.
-- `this` -- is the "current" element, the one that has a currently running handler on it.
+- `event.target` -- это "исходный" элемент, на котором произошло событие, в процессе всплытия он неизменен.
+- `this` -- это "текущий" элемент, до которого дошло всплытие, на нём сейчас выполняется обработчик.
 
-For instance, if we have a single handler `form.onclick`, then it can "catch" all clicks inside the form. No matter where the click happened, it bubbles up to `<form>` and runs the handler.
+Например, если стоит только один обработчик `form.onclick`, то он "поймает" все клики внутри формы. Где бы ни был клик внутри –- он всплывёт до элемента `<form>`, на котором сработает обработчик.
 
-In `form.onclick` handler:
+При этом внутри обработчика`form.onclick`:
 
-- `this` (`=event.currentTarget`) is the `<form>` element, because the handler runs on it.
-- `event.target` is the concrete element inside the form that actually was clicked.
+- `this` (`=event.currentTarget`) всегда будет элемент `<form>`, так как обработчик сработал на ней.
+- `event.target` будет содержать ссылку на конкретный элемент внутри формы, на котором произошёл клик.
 
-Check it out:
+Попробуйте сами:
 
 [codetabs height=220 src="bubble-target"]
 
-It's possible that `event.target` equals `this` -- when the click is made directly on the `<form>` element.
+Возможна и ситуация, когда `event.target` и `this` -- один и тот же элемент, например, если клик был на самом элементе `<form>`.
 
-## Stopping bubbling
+## Прекращение всплытия
 
-A bubbling event goes from the target element straight up. Normally it goes upwards till `<html>`, and then to `document` object, and some events even reach `window`, calling all handlers on the path.
+Всплытие идёт с "исходного" элемента прямо наверх. По умолчанию событие будет всплывать до элемента `<html>`, а затем до объекта `document`, а иногда даже до `window`, вызывая все обработчики на своем пути.
 
-But any handler may decide that the event has been fully processed and stop the bubbling.
+Но любой промежуточный обработчик может решить, что событие полностью обработано, и остановить всплытие.
 
-The method for it is `event.stopPropagation()`.
+Для этого нужно вызвать метод `event.stopPropagation()`.
 
-For instance, here `body.onclick` doesn't work if you click on `<button>`:
+Например, здесь при клике на кнопку `<button>` обработчик `body.onclick` не сработает:
 
 ```html run autorun height=60
-<body onclick="alert(`the bubbling doesn't reach here`)">
-  <button onclick="event.stopPropagation()">Click me</button>
+<body onclick="alert(`сюда всплытие не дойдёт`)">
+  <button onclick="event.stopPropagation()">Кликни меня</button>
 </body>
 ```
 
 ```smart header="event.stopImmediatePropagation()"
-If an element has multiple event handlers on a single event, then even if one of them stops the bubbling, the other ones still execute.
+Если у элемента есть несколько обработчиков на одно событие, то даже при прекращении всплытия все они будут выполнены.
 
-In other words, `event.stopPropagation()` stops the move upwards, but on the current element all other handlers will run.
+То есть, `event.stopPropagation()` препятствует продвижению события дальше, но на текущем элементе все обработчики будут вызваны.
 
-To stop the bubbling and prevent handlers on the current element from running, there's a method `event.stopImmediatePropagation()`. After it no other handlers execute.
+Для того, чтобы полностью остановить обработку, существует метод `event.stopImmediatePropagation()`. Он не только предотвращает всплытие, но и останавливает обработку событий на текущем элементе.
 ```
 
-```warn header="Don't stop bubbling without a need!"
-Bubbling is convenient. Don't stop it without a real need: obvious and architecturally well-thought.
+```warn header="Не прекращайте всплытие без необходимости!"
+Всплытие -- это удобно. Не прекращайте его без явной нужды, очевидной и архитектурно прозрачной.
 
-Sometimes `event.stopPropagation()` creates hidden pitfalls that later may become problems.
+Зачастую прекращение всплытия через `event.stopPropagation()` свои подводные камни, которые со временем могут стать проблемами.
 
-For instance:
+Например:
 
-1. We create a nested menu. Each submenu handles clicks on its elements and calls `stopPropagation` so that the outer menu won't trigger.
-2. Later we decide to catch clicks on the whole window, to track users' behavior (where people click). Some analytic systems do that. Usually the code uses `document.addEventListener('click'…)` to catch all clicks.
-3. Our analytic won't work over the area where clicks are stopped by `stopPropagation`. We've got a "dead zone".
+1. Мы делаем вложенное меню. Оно обрабатывает клики на своих элементах и делает для них `stopPropagation`, чтобы не открывать внешнее меню.
+2. Позже мы решили отслеживать все клики в окне, для какой-то своей функциональности, к примеру, для статистики – где вообще у нас кликают люди. Некоторые системы аналитики так делают. Обычно используют `document.addEventListener('click'…)`, чтобы отлавливать все клики.
+3. Наша аналитика не будет работать над областью, где клики прекращаются `stopPropagation`. Получилась «мёртвая зона».
 
-There's usually no real need to prevent the bubbling. A task that seemingly requires that may be solved by other means. One of them is to use custom events, we'll cover them later. Also we can write our data into the `event` object in one handler and read it in another one, so we can pass to handlers on parents information about the processing below.
+Зачастую нет никакой необходимости прекращать всплытие. Задача, которая, казалось бы, требует этого, может быть решена иначе. Например, с помощью создания своего уникального события, о том, как это делать, мы поговорим позже. Также мы можем записывать какаю-то служебную информацию в объект `event` в одном обработчике, а читать в другом, таким образом мы можем сообщить родительскому, что обрабатывать событие уже не нужно.
 ```
 
 

From 1e1034923c14dfa6b6f35883aa2c5cbfbd0a3a84 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Tue, 21 May 2019 13:16:34 +0300
Subject: [PATCH 03/15] 02-bubbling-and-capturing: Translate capture phase
 paragraph

---
 .../02-bubbling-and-capturing/article.md      | 54 +++++++++----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 621d6b3a44..6698103692 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -116,42 +116,42 @@
 ```
 
 
-## Capturing
+## Погружение
 
-There's another phase of event processing called "capturing". It is rarely used in real code, but sometimes can be useful.
+Существует еще одна фаза из жизненного цикла события -- "погружение". Она очень редко используется в реальном коде, однако тоже может быть полезной.
 
-The standard [DOM Events](http://www.w3.org/TR/DOM-Level-3-Events/) describes 3 phases of event propagation:
+Стандарт [DOM Events](http://www.w3.org/TR/DOM-Level-3-Events/) описывает 3 фазы прохода события:
 
-1. Capturing phase -- the event goes down to the element.
-2. Target phase -- the event reached the target element.
-3. Bubbling phase -- the event bubbles up from the element.
+1. Фаза перехвата (capturing phase) -- событие сначала идет сверху вниз.
+2. Фаза цели (target phase) -- событие достигло целевого(исходного) элемента.
+3. Фаза всплытия (bubbling stage) -- событие начинает всплывать.
 
-Here's the picture of a click on `<td>` inside a table, taken from the specification:
+Картинка из спецификации демонстрирует, как это работает при клике по ячейке `<td>`, расположенной внутри таблицы:
 
 ![](eventflow.png)
 
-That is: for a click on `<td>` the event first goes through the ancestors chain down to the element (capturing), then it reaches the target, and then it goes up (bubbles), calling handlers on its way.
+То есть, при клике на `<td>` событие путешествует по цепочке родителей сначала вниз к элементу (погружается), затем оно достигает целевой элемент, а потом наверх (всплывает), по пути вызывая обработчики.
 
-**Before we only talked about bubbling, because the capturing phase is rarely used. Normally it is invisible to us.**
+**Ранее мы говорили только о всплытии, потому что другие стадии, как правило, не используются и проходят незаметно для нас.**
 
-Handlers added using `on<event>`-property or using HTML attributes or using `addEventListener(event, handler)` don't know anything about capturing, they only run on the 2nd and 3rd phases.
+Обработчики, добавленные через `on<event>`-свойство или через HTML-атрибуты или через `addEventListener(event, handler)`, ничего не знают о фазе перехвата, а работают только на 2-ой и 3-ей фазах.
 
-To catch an event on the capturing phase, we need to set the handler `capture` option to `true`:
+Чтобы поймать событие на стадии перехвата, нужно использовать третий аргумент `capture` вот так:
 
 ```js
 elem.addEventListener(..., {capture: true})
-// or, just "true" is an alias to {capture: true}
+// или просто "true", как сокращение к {capture: true}
 elem.addEventListener(..., true)
 ```
 
-There are two possible values of the `capture` option:
+Существуют два варианта значения аргумента `capture`:
 
-- If it's `false` (default), then the handler is set on the bubbling phase.
-- If it's `true`, then the handler is set on the capturing phase.
+- Если аргумент `false` (по умолчанию), то событие будет поймано при всплытии.
+- Если аргумент `true`, то событие будет перехвачено по дороге вниз при погружении.
 
-Note that while formally there are 3 phases, the 2nd phase ("target phase": the event reached the element) is not handled separately: handlers on both capturing and bubbling phases trigger at that phase.
+Обратите внимание, что хоть и формально существует 3 фазы, 2-ую фазу ("фазу цели": событие достигло элемента) нельзя обработать отдельно, при ее достижении вызываются все обработчики: и на всплытие, и на погружение.
 
-Let's see both capturing and bubbling in action:
+Давайте посмотрим на это в действии:
 
 ```html run autorun height=140 edit
 <style>
@@ -169,25 +169,25 @@ Let's see both capturing and bubbling in action:
 
 <script>
   for(let elem of document.querySelectorAll('*')) {
-    elem.addEventListener("click", e => alert(`Capturing: ${elem.tagName}`), true);
-    elem.addEventListener("click", e => alert(`Bubbling: ${elem.tagName}`));
+    elem.addEventListener("click", e => alert(`Погружение: ${elem.tagName}`), true);
+    elem.addEventListener("click", e => alert(`Всплытие: ${elem.tagName}`));
   }
 </script>
 ```
 
-The code sets click handlers on *every* element in the document to see which ones are working.
+Здесь обработчики навешиваются на *каждый* элемент в документе, чтобы увидеть в каком порядке они вызываются по мере прохода события.
 
-If you click on `<p>`, then the sequence is:
+Если вы кликните по `<p>`, то последовательность следующая:
 
-1. `HTML` -> `BODY` -> `FORM` -> `DIV` -> `P` (capturing phase, the first listener), and then:
-2. `P` -> `DIV` -> `FORM` -> `BODY` -> `HTML` (bubbling phase, the second listener).
+1. `HTML` -> `BODY` -> `FORM` -> `DIV` -> `P` (фаза погружения, первый обработчик), а потом:
+2. `P` -> `DIV` -> `FORM` -> `BODY` -> `HTML` (фаза всплытия, второй обработчик).
 
-Please note that `P` shows up two times: at the end of capturing and at the start of bubbling.
+Обратите внимание, что `P` появляется два раза: в конце погружения и в начале всплытия.
 
-There's a property `event.eventPhase` that tells us the number of the phase on which the event was caught. But it's rarely used, because we usually know it in the handler.
+Существует свойство `event.eventPhase` содержащее номер фазы, на которой событие было поймано. Но оно используется редко, ведь мы обычно знаем об этом в обработчике.
 
-```smart header="To remove the handler, `removeEventListener` needs the same phase"
-If we `addEventListener(..., true)`, then we should mention the same phase in `removeEventListener(..., true)` to correctly remove the handler.
+```smart header="Чтобы убрать обработчик, `removeEventListener` нужна та же фаза"
+Если мы добавили обработчик вот так `addEventListener(..., true)`, то мы должны передать то же значение аргумента `capture` в `removeEventListener(..., true)`, когда снимаем обработчик.
 ```
 
 ## Summary

From a71ed746f44adb673f561d65cd246d88dbae4d42 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Tue, 21 May 2019 14:03:13 +0300
Subject: [PATCH 04/15] 02-bubbling-and-capturing: translate summary

---
 .../02-bubbling-and-capturing/article.md      | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 6698103692..97208d91e1 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -190,26 +190,26 @@ elem.addEventListener(..., true)
 Если мы добавили обработчик вот так `addEventListener(..., true)`, то мы должны передать то же значение аргумента `capture` в `removeEventListener(..., true)`, когда снимаем обработчик.
 ```
 
-## Summary
+## Итого
 
-The event handling process:
+Алгоритм:
 
-- When an event happens -- the most nested element where it happens gets labeled as the "target element" (`event.target`).
-- Then the event first moves from the document root down to the `event.target`, calling handlers assigned with `addEventListener(...., true)` on the way (`true` is a shorthand for `{capture: true}`).
-- Then the event moves from `event.target` up to the root, calling handlers assigned using  `on<event>` and `addEventListener` without the 3rd argument or with the 3rd argument `false`.
+- При наступлении события -- элемент, на котором оно произошло, помечается как "целевой" (`event.target`).
+- Далее событие сначала двигается вниз от корня документа к `event.target`, по пути вызывая обработчики, поставленные через `addEventListener(...., true), где `true` -- это сокращение для `{capture: true}`.
+- Далее событие двигается от `event.target` вверх к корню документа, по пути вызывая обработчики, поставленные через `on<event>` и `addEventListener` без третьего аргумента или с третьим аргументом равным `false`.
 
-Each handler can access `event` object properties:
+Каждый обработчик имеет доступ к свойствам события `event`:
 
-- `event.target` -- the deepest element that originated the event.
-- `event.currentTarget` (=`this`) -- the current element that handles the event (the one that has the handler on it)
-- `event.eventPhase` -- the current phase (capturing=1, bubbling=3).
+- `event.target` -- самый глубокий элемент, на котором произошло событие.
+- `event.currentTarget` (=`this`) -- элемент, на котором в данный момент сработал обработчик (тот, на котором "висит" конкретный обработчик)
+- `event.eventPhase` -- на какой фазе он сработал (погружение=1, всплытие=3).
 
-Any event handler can stop the event by calling `event.stopPropagation()`, but that's not recommended, because we can't really be sure we won't need it above, maybe for completely different things.
+Любой обработчик может остановить событие вызовом `event.stopPropagation()`, но делать это не рекомендуется, так как в дальнейшем это событие может понадобиться, иногда для самых неожиданных вещей.
 
-The capturing phase is used very rarely, usually we handle events on bubbling. And there's a logic behind that.
+В современной разработке стадия погружения используется очень редко, обычно события обрабатываются во время всплытия. И в этом есть скрытый смысл.
 
-In real world, when an accident happens, local authorities react first. They know best the area where it happened. Then higher-level authorities if needed.
+В реальном мире, когда происходит чрезвычайная ситуация, местные службы реагируют первыми. Они знают лучше всех местность, в которой это произошло, и другие детали. Вышестоящие инстанции подключаются уже после этого при необходимости.
 
-The same for event handlers. The code that set the handler on a particular element knows maximum  details about the element and what it does. A handler on a particular `<td>` may be suited for that exactly `<td>`, it knows everything about it, so it should get the chance first. Then its immediate parent also knows about the context, but a little bit less, and so on till the very top element that handles general concepts and runs the last.
+Тоже самое справедливо для обработчиков событий. Код, который "навесил" обработчик на конкретный элемент, знает максимум деталей об элементе и его предназначении. Например, обработчик на определенном `<td>` скорее всего подходит только для этого конкретного `<td>`, он знает все о нем, поэтому он должен отработать первым. Далее имеет смысл передать обработку события родителю -- он тоже понимает, что происходит, но уже менее детально, далее – выше, и так далее, до самого объекта `document`, обработчик на котором реализовывает самую общую функциональность уровня документа.
 
-Bubbling and capturing lay the foundation for "event delegation" -- an extremely powerful event handling pattern that we study in the next chapter.
+Всплытие и погружение являются основой для "делегирования событий" -- очень мощного приема обработки событий. Его мы изучим в следующей главе.
\ No newline at end of file

From 347167b4718017e4ef7df5176023361a7063df9f Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Tue, 21 May 2019 14:17:39 +0300
Subject: [PATCH 05/15] 02-bubbling-and-capturing: Replace e with yo

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 97208d91e1..e1ecef38fc 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -45,7 +45,7 @@
 
 Поэтому если кликнуть на `<p>`, то мы увидим три оповещения: `p` -> `div` -> `form`.
 
-Этот процесс называется "всплытием", потому что события "всплывают" от внутреннего элемента вверх через родителей, подобно тому, как всплывает пузырек воздуха в воде.
+Этот процесс называется "всплытием", потому что события "всплывают" от внутреннего элемента вверх через родителей, подобно тому, как всплывает пузырёк воздуха в воде.
 
 ```warn header="*Почти* все события всплывают."
 Ключевое слово в этой фразе -- "почти".
@@ -79,7 +79,7 @@
 
 ## Прекращение всплытия
 
-Всплытие идёт с "исходного" элемента прямо наверх. По умолчанию событие будет всплывать до элемента `<html>`, а затем до объекта `document`, а иногда даже до `window`, вызывая все обработчики на своем пути.
+Всплытие идёт с "исходного" элемента прямо наверх. По умолчанию событие будет всплывать до элемента `<html>`, а затем до объекта `document`, а иногда даже до `window`, вызывая все обработчики на своём пути.
 
 Но любой промежуточный обработчик может решить, что событие полностью обработано, и остановить всплытие.
 
@@ -118,11 +118,11 @@
 
 ## Погружение
 
-Существует еще одна фаза из жизненного цикла события -- "погружение". Она очень редко используется в реальном коде, однако тоже может быть полезной.
+Существует ещё одна фаза из жизненного цикла события -- "погружение". Она очень редко используется в реальном коде, однако тоже может быть полезной.
 
 Стандарт [DOM Events](http://www.w3.org/TR/DOM-Level-3-Events/) описывает 3 фазы прохода события:
 
-1. Фаза перехвата (capturing phase) -- событие сначала идет сверху вниз.
+1. Фаза перехвата (capturing phase) -- событие сначала идёт сверху вниз.
 2. Фаза цели (target phase) -- событие достигло целевого(исходного) элемента.
 3. Фаза всплытия (bubbling stage) -- событие начинает всплывать.
 
@@ -149,7 +149,7 @@ elem.addEventListener(..., true)
 - Если аргумент `false` (по умолчанию), то событие будет поймано при всплытии.
 - Если аргумент `true`, то событие будет перехвачено по дороге вниз при погружении.
 
-Обратите внимание, что хоть и формально существует 3 фазы, 2-ую фазу ("фазу цели": событие достигло элемента) нельзя обработать отдельно, при ее достижении вызываются все обработчики: и на всплытие, и на погружение.
+Обратите внимание, что хоть и формально существует 3 фазы, 2-ую фазу ("фазу цели": событие достигло элемента) нельзя обработать отдельно, при её достижении вызываются все обработчики: и на всплытие, и на погружение.
 
 Давайте посмотрим на это в действии:
 
@@ -210,6 +210,6 @@ elem.addEventListener(..., true)
 
 В реальном мире, когда происходит чрезвычайная ситуация, местные службы реагируют первыми. Они знают лучше всех местность, в которой это произошло, и другие детали. Вышестоящие инстанции подключаются уже после этого при необходимости.
 
-Тоже самое справедливо для обработчиков событий. Код, который "навесил" обработчик на конкретный элемент, знает максимум деталей об элементе и его предназначении. Например, обработчик на определенном `<td>` скорее всего подходит только для этого конкретного `<td>`, он знает все о нем, поэтому он должен отработать первым. Далее имеет смысл передать обработку события родителю -- он тоже понимает, что происходит, но уже менее детально, далее – выше, и так далее, до самого объекта `document`, обработчик на котором реализовывает самую общую функциональность уровня документа.
+Тоже самое справедливо для обработчиков событий. Код, который "навесил" обработчик на конкретный элемент, знает максимум деталей об элементе и его предназначении. Например, обработчик на определённом `<td>` скорее всего подходит только для этого конкретного `<td>`, он знает все о нем, поэтому он должен отработать первым. Далее имеет смысл передать обработку события родителю -- он тоже понимает, что происходит, но уже менее детально, далее – выше, и так далее, до самого объекта `document`, обработчик на котором реализовывает самую общую функциональность уровня документа.
 
-Всплытие и погружение являются основой для "делегирования событий" -- очень мощного приема обработки событий. Его мы изучим в следующей главе.
\ No newline at end of file
+Всплытие и погружение являются основой для "делегирования событий" -- очень мощного приёма обработки событий. Его мы изучим в следующей главе.
\ No newline at end of file

From 864c09cd3fec2a49a2b50670ddb0bfd2584689f2 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Tue, 21 May 2019 14:19:28 +0300
Subject: [PATCH 06/15] 02-bubbling-and-capturing: Change translation for
 event.target

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index e1ecef38fc..1ebafc1f01 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -57,11 +57,11 @@
 
 Всегда можно узнать, на каком конкретно элементе произошло событие.
 
-**Самый глубокий элемент, который вызывает событие, называется *исходным* элементом, и он доступен через `event.target`.**
+**Самый глубокий элемент, который вызывает событие, называется *целевым* элементом, и он доступен через `event.target`.**
 
 Отличия от `this` (=`event.currentTarget`):
 
-- `event.target` -- это "исходный" элемент, на котором произошло событие, в процессе всплытия он неизменен.
+- `event.target` -- это "целевой" элемент, на котором произошло событие, в процессе всплытия он неизменен.
 - `this` -- это "текущий" элемент, до которого дошло всплытие, на нём сейчас выполняется обработчик.
 
 Например, если стоит только один обработчик `form.onclick`, то он "поймает" все клики внутри формы. Где бы ни был клик внутри –- он всплывёт до элемента `<form>`, на котором сработает обработчик.
@@ -79,7 +79,7 @@
 
 ## Прекращение всплытия
 
-Всплытие идёт с "исходного" элемента прямо наверх. По умолчанию событие будет всплывать до элемента `<html>`, а затем до объекта `document`, а иногда даже до `window`, вызывая все обработчики на своём пути.
+Всплытие идёт с "целевого" элемента прямо наверх. По умолчанию событие будет всплывать до элемента `<html>`, а затем до объекта `document`, а иногда даже до `window`, вызывая все обработчики на своём пути.
 
 Но любой промежуточный обработчик может решить, что событие полностью обработано, и остановить всплытие.
 

From cdf666a6d447a201b90bcc765a33d4d2d10c520a Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Tue, 21 May 2019 14:23:18 +0300
Subject: [PATCH 07/15] 02-bubbling-and-capturing: Translate bubble-target
 example template

---
 .../02-bubbling-and-capturing/bubble-target.view/index.html     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
index 8313ec29fe..10523f904e 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
+++ b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
@@ -7,7 +7,7 @@
 </head>
 
 <body>
-  A click shows both <code>event.target</code> and <code>this</code> to compare:
+  Клик покажет оба: и <code>event.target</code> и <code>this</code> для сравнения:
 
   <form id="form">FORM
     <div>DIV

From e5f7c1e38583a03561a2d4b18bc2a16c80a967cb Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Wed, 22 May 2019 22:41:57 +0300
Subject: [PATCH 08/15] 02-bubbling-and-capturing: replace e with yo, add word

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 1ebafc1f01..0a8edabac3 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -208,8 +208,8 @@ elem.addEventListener(..., true)
 
 В современной разработке стадия погружения используется очень редко, обычно события обрабатываются во время всплытия. И в этом есть скрытый смысл.
 
-В реальном мире, когда происходит чрезвычайная ситуация, местные службы реагируют первыми. Они знают лучше всех местность, в которой это произошло, и другие детали. Вышестоящие инстанции подключаются уже после этого при необходимости.
+В реальном мире, когда происходит чрезвычайная ситуация, местные службы реагируют первыми. Они знают лучше всех местность, в которой это произошло, и другие детали. Вышестоящие инстанции подключаются уже после этого и при необходимости.
 
-Тоже самое справедливо для обработчиков событий. Код, который "навесил" обработчик на конкретный элемент, знает максимум деталей об элементе и его предназначении. Например, обработчик на определённом `<td>` скорее всего подходит только для этого конкретного `<td>`, он знает все о нем, поэтому он должен отработать первым. Далее имеет смысл передать обработку события родителю -- он тоже понимает, что происходит, но уже менее детально, далее – выше, и так далее, до самого объекта `document`, обработчик на котором реализовывает самую общую функциональность уровня документа.
+Тоже самое справедливо для обработчиков событий. Код, который "навесил" обработчик на конкретный элемент, знает максимум деталей об элементе и его предназначении. Например, обработчик на определённом `<td>` скорее всего подходит только для этого конкретного `<td>`, он знает все о нём, поэтому он должен отработать первым. Далее имеет смысл передать обработку события родителю -- он тоже понимает, что происходит, но уже менее детально, далее – выше, и так далее, до самого объекта `document`, обработчик на котором реализовывает самую общую функциональность уровня документа.
 
 Всплытие и погружение являются основой для "делегирования событий" -- очень мощного приёма обработки событий. Его мы изучим в следующей главе.
\ No newline at end of file

From 0d78146ea5e0ef54493f7e64697e7f0cd451d38e Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Fri, 31 May 2019 13:53:56 +0300
Subject: [PATCH 09/15] 02-bubbling-and-capturing: Fix typos, punctuation and
 spelling

---
 .../02-bubbling-and-capturing/article.md      | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 0a8edabac3..f205990345 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -2,7 +2,7 @@
 
 Давайте начнём с примера.
 
-Этот обработчик для `<div>` сработает, если вы кликните по вложенному тегу `<em>` или `<code>`:
+Этот обработчик для `<div>` сработает, если вы кликните по любому из вложенных тегов `<em>` или `<code>`:
 
 ```html autorun height=60
 <div onclick="alert('Обработчик!')">
@@ -16,9 +16,9 @@
 
 Принцип всплытия очень простой.
 
-**Когда на элементе происходит событие, обработчики сначала срабатывают на нём, потом на его родителе, затем выше и так далее, вверх по цепочке вложенности.**
+**Когда на элементе происходит событие, обработчики сначала срабатывают на нём, потом на его родителе, затем выше и так далее, вверх по цепочке предков.**
 
-Например, есть 3 вложенных элемента `FORM > DIV > P`, с обработчиком на каждом:
+Например, есть 3 вложенных элемента `FORM > DIV > P` с обработчиком на каждом:
 
 ```html run autorun
 <style>
@@ -45,7 +45,7 @@
 
 Поэтому если кликнуть на `<p>`, то мы увидим три оповещения: `p` -> `div` -> `form`.
 
-Этот процесс называется "всплытием", потому что события "всплывают" от внутреннего элемента вверх через родителей, подобно тому, как всплывает пузырёк воздуха в воде.
+Этот процесс называется "всплытием", потому что события "всплывают" от внутреннего элемента вверх через родителей подобно тому, как всплывает пузырёк воздуха в воде.
 
 ```warn header="*Почти* все события всплывают."
 Ключевое слово в этой фразе -- "почти".
@@ -104,19 +104,19 @@
 ```warn header="Не прекращайте всплытие без необходимости!"
 Всплытие -- это удобно. Не прекращайте его без явной нужды, очевидной и архитектурно прозрачной.
 
-Зачастую прекращение всплытия через `event.stopPropagation()` свои подводные камни, которые со временем могут стать проблемами.
+Зачастую прекращение всплытия через `event.stopPropagation()` имеет свои подводные камни, которые со временем могут стать проблемами.
 
 Например:
 
-1. Мы делаем вложенное меню. Оно обрабатывает клики на своих элементах и делает для них `stopPropagation`, чтобы не открывать внешнее меню.
-2. Позже мы решили отслеживать все клики в окне, для какой-то своей функциональности, к примеру, для статистики – где вообще у нас кликают люди. Некоторые системы аналитики так делают. Обычно используют `document.addEventListener('click'…)`, чтобы отлавливать все клики.
+1. Мы делаем вложенное меню.  Каждое подменю обрабатывает клики на своих элементах и делает для них `stopPropagation`, чтобы не открывать внешнее меню.
+2. Позже мы решили отслеживать все клики в окне для какой-то своей функциональности, к примеру, для статистики – где вообще у нас кликают люди. Некоторые системы аналитики так делают. Обычно используют `document.addEventListener('click'…)`, чтобы отлавливать все клики.
 3. Наша аналитика не будет работать над областью, где клики прекращаются `stopPropagation`. Получилась «мёртвая зона».
 
-Зачастую нет никакой необходимости прекращать всплытие. Задача, которая, казалось бы, требует этого, может быть решена иначе. Например, с помощью создания своего уникального события, о том, как это делать, мы поговорим позже. Также мы можем записывать какаю-то служебную информацию в объект `event` в одном обработчике, а читать в другом, таким образом мы можем сообщить родительскому, что обрабатывать событие уже не нужно.
+Зачастую нет никакой необходимости прекращать всплытие. Задача, которая, казалось бы, требует этого, может быть решена иначе. Например, с помощью создания своего уникального события, о том, как это делать, мы поговорим позже. Также мы можем записывать какую-то служебную информацию в объект `event` в одном обработчике, а читать в другом, таким образом мы можем сообщить обработчикам на родительских элементах информацию о том, что событие уже было как-то обработано.
 ```
 
 
-## Погружение
+## Погружение(перехват)
 
 Существует ещё одна фаза из жизненного цикла события -- "погружение". Она очень редко используется в реальном коде, однако тоже может быть полезной.
 
@@ -130,21 +130,21 @@
 
 ![](eventflow.png)
 
-То есть, при клике на `<td>` событие путешествует по цепочке родителей сначала вниз к элементу (погружается), затем оно достигает целевой элемент, а потом наверх (всплывает), по пути вызывая обработчики.
+То есть при клике на `<td>` событие путешествует по цепочке родителей сначала вниз к элементу (погружается), затем оно достигает целевой элемент, а потом всплывает наверх, вызывая по пути обработчики.
 
 **Ранее мы говорили только о всплытии, потому что другие стадии, как правило, не используются и проходят незаметно для нас.**
 
-Обработчики, добавленные через `on<event>`-свойство или через HTML-атрибуты или через `addEventListener(event, handler)`, ничего не знают о фазе перехвата, а работают только на 2-ой и 3-ей фазах.
+Обработчики, добавленные через `on<event>`-свойство или через HTML-атрибуты, или через `addEventListener(event, handler)`, ничего не знают о фазе перехвата, а работают только на 2-ой и 3-ей фазах.
 
 Чтобы поймать событие на стадии перехвата, нужно использовать третий аргумент `capture` вот так:
 
 ```js
 elem.addEventListener(..., {capture: true})
-// или просто "true", как сокращение к {capture: true}
+// или просто "true", как сокращение для {capture: true}
 elem.addEventListener(..., true)
 ```
 
-Существуют два варианта значения аргумента `capture`:
+Существуют два варианта значений аргумента `capture`:
 
 - Если аргумент `false` (по умолчанию), то событие будет поймано при всплытии.
 - Если аргумент `true`, то событие будет перехвачено по дороге вниз при погружении.
@@ -184,7 +184,7 @@ elem.addEventListener(..., true)
 
 Обратите внимание, что `P` появляется два раза: в конце погружения и в начале всплытия.
 
-Существует свойство `event.eventPhase` содержащее номер фазы, на которой событие было поймано. Но оно используется редко, ведь мы обычно знаем об этом в обработчике.
+Существует свойство `event.eventPhase`, содержащее номер фазы, на которой событие было поймано. Но оно используется редко, ведь мы обычно знаем об этом в обработчике.
 
 ```smart header="Чтобы убрать обработчик, `removeEventListener` нужна та же фаза"
 Если мы добавили обработчик вот так `addEventListener(..., true)`, то мы должны передать то же значение аргумента `capture` в `removeEventListener(..., true)`, когда снимаем обработчик.

From 5c0ea1707514deca86976c22c8bf8283a3eba5e0 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 2 Jun 2019 14:14:21 +0300
Subject: [PATCH 10/15] 02-bubbling-and-capturing: Remove redundant line

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index f205990345..1800d87f15 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -151,7 +151,7 @@ elem.addEventListener(..., true)
 
 Обратите внимание, что хоть и формально существует 3 фазы, 2-ую фазу ("фазу цели": событие достигло элемента) нельзя обработать отдельно, при её достижении вызываются все обработчики: и на всплытие, и на погружение.
 
-Давайте посмотрим на это в действии:
+Давайте посмотрим и всплытие и погружение в действии:
 
 ```html run autorun height=140 edit
 <style>

From cc5574e7122684be21530e75bfe7e1f778279aa6 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sat, 15 Jun 2019 20:58:26 +0300
Subject: [PATCH 11/15] 02-bubbling-and-capturing: Translate comment in
 example, fix punctuation

---
 .../02-bubbling-and-capturing/bubble-target.view/index.html     | 2 +-
 .../02-bubbling-and-capturing/bubble-target.view/script.js      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
index 10523f904e..9dabcad90f 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
+++ b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/index.html
@@ -7,7 +7,7 @@
 </head>
 
 <body>
-  Клик покажет оба: и <code>event.target</code> и <code>this</code> для сравнения:
+  Клик покажет оба: и <code>event.target</code>, и <code>this</code> для сравнения:
 
   <form id="form">FORM
     <div>DIV
diff --git a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
index b1353712fa..45d3459fe7 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
+++ b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
@@ -2,7 +2,7 @@
 form.onclick = function(event) {
   event.target.style.backgroundColor = 'yellow';
 
-  // chrome needs some time to paint yellow
+  // браузеру нужно некоторое время, чтобы зарисовать всё жёлтым
   setTimeout(() => {
     alert("target = " + event.target.tagName + ", this=" + this.tagName);
     event.target.style.backgroundColor = ''

From e3de6c2b517805b0120efd25c6188028e0a0b2c1 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 16 Jun 2019 13:18:30 +0300
Subject: [PATCH 12/15] 02-bubbling-and-capturing: Improve translation

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 1800d87f15..c7ef1fe48c 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -2,7 +2,7 @@
 
 Давайте начнём с примера.
 
-Этот обработчик для `<div>` сработает, если вы кликните по любому из вложенных тегов `<em>` или `<code>`:
+Этот обработчик для `<div>` сработает, если вы кликните по любому из вложенных тегов, будь то `<em>` или `<code>`:
 
 ```html autorun height=60
 <div onclick="alert('Обработчик!')">

From 4020eaa326444a1c0d0b02dce2fceeee9583c9e3 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 16 Jun 2019 13:23:53 +0300
Subject: [PATCH 13/15]  02-bubbling-and-capturing: Stick with unified version
 of 'capturing' translation

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index c7ef1fe48c..a0eefe3c37 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -1,4 +1,4 @@
-# Всплытие и перехват
+# Всплытие и погружение
 
 Давайте начнём с примера.
 
@@ -116,13 +116,13 @@
 ```
 
 
-## Погружение(перехват)
+## Погружение
 
-Существует ещё одна фаза из жизненного цикла события -- "погружение". Она очень редко используется в реальном коде, однако тоже может быть полезной.
+Существует ещё одна фаза из жизненного цикла события -- "погружение", в других источниках её могут называть -- "перехват", но мы будем использовать первый вариант. Она очень редко используется в реальном коде, однако тоже может быть полезной.
 
 Стандарт [DOM Events](http://www.w3.org/TR/DOM-Level-3-Events/) описывает 3 фазы прохода события:
 
-1. Фаза перехвата (capturing phase) -- событие сначала идёт сверху вниз.
+1. Фаза погружения (capturing phase) -- событие сначала идёт сверху вниз.
 2. Фаза цели (target phase) -- событие достигло целевого(исходного) элемента.
 3. Фаза всплытия (bubbling stage) -- событие начинает всплывать.
 
@@ -134,9 +134,9 @@
 
 **Ранее мы говорили только о всплытии, потому что другие стадии, как правило, не используются и проходят незаметно для нас.**
 
-Обработчики, добавленные через `on<event>`-свойство или через HTML-атрибуты, или через `addEventListener(event, handler)`, ничего не знают о фазе перехвата, а работают только на 2-ой и 3-ей фазах.
+Обработчики, добавленные через `on<event>`-свойство или через HTML-атрибуты, или через `addEventListener(event, handler)`, ничего не знают о фазе погружения, а работают только на 2-ой и 3-ей фазах.
 
-Чтобы поймать событие на стадии перехвата, нужно использовать третий аргумент `capture` вот так:
+Чтобы поймать событие на стадии погружения, нужно использовать третий аргумент `capture` вот так:
 
 ```js
 elem.addEventListener(..., {capture: true})

From 46790be29804f20e3506f9b81cac94b7d94be893 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 16 Jun 2019 13:26:04 +0300
Subject: [PATCH 14/15] 02-bubbling-and-capturing: Minor translation
 improvements

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index a0eefe3c37..d83a7e23d0 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -144,10 +144,10 @@ elem.addEventListener(..., {capture: true})
 elem.addEventListener(..., true)
 ```
 
-Существуют два варианта значений аргумента `capture`:
+Существуют два варианта значений опции `capture`:
 
 - Если аргумент `false` (по умолчанию), то событие будет поймано при всплытии.
-- Если аргумент `true`, то событие будет перехвачено по дороге вниз при погружении.
+- Если аргумент `true`, то событие будет перехвачено при погружении.
 
 Обратите внимание, что хоть и формально существует 3 фазы, 2-ую фазу ("фазу цели": событие достигло элемента) нельзя обработать отдельно, при её достижении вызываются все обработчики: и на всплытие, и на погружение.
 
@@ -206,7 +206,7 @@ elem.addEventListener(..., true)
 
 Любой обработчик может остановить событие вызовом `event.stopPropagation()`, но делать это не рекомендуется, так как в дальнейшем это событие может понадобиться, иногда для самых неожиданных вещей.
 
-В современной разработке стадия погружения используется очень редко, обычно события обрабатываются во время всплытия. И в этом есть скрытый смысл.
+В современной разработке стадия погружения используется очень редко, обычно события обрабатываются во время всплытия. И в этом есть логика.
 
 В реальном мире, когда происходит чрезвычайная ситуация, местные службы реагируют первыми. Они знают лучше всех местность, в которой это произошло, и другие детали. Вышестоящие инстанции подключаются уже после этого и при необходимости.
 

From 767ac4853c8b7fa82e7c8bbf5f8f3bd8cb298bc4 Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sun, 16 Jun 2019 19:17:04 +0300
Subject: [PATCH 15/15] 02-bubbling-and-capturing: Change phrase in capturing
 paragraph

---
 2-ui/2-events/02-bubbling-and-capturing/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index d83a7e23d0..f46fae7032 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -118,7 +118,7 @@
 
 ## Погружение
 
-Существует ещё одна фаза из жизненного цикла события -- "погружение", в других источниках её могут называть -- "перехват", но мы будем использовать первый вариант. Она очень редко используется в реальном коде, однако тоже может быть полезной.
+Существует ещё одна фаза из жизненного цикла события -- "погружение" (иногда её называют "перехват"). Она очень редко используется в реальном коде, однако тоже может быть полезной.
 
 Стандарт [DOM Events](http://www.w3.org/TR/DOM-Level-3-Events/) описывает 3 фазы прохода события: