From 437bb8af9df18d23abe3f9b58b782a10517af8e9 Mon Sep 17 00:00:00 2001
From: Mari-Gogolashvili <133369792+Mari-Gogolashvili@users.noreply.github.com>
Date: Sun, 21 Jan 2024 14:58:07 +0400
Subject: [PATCH 1/2] changed input-output.md ,
 property-and-attribute-binding.md and two-way-binding.md

---
 src/articles/data-binding/input-output.md                   | 4 ++--
 src/articles/data-binding/property-and-attribute-binding.md | 6 +++---
 src/articles/data-binding/two-way-binding.md                | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/articles/data-binding/input-output.md b/src/articles/data-binding/input-output.md
index e519646..2df3e14 100644
--- a/src/articles/data-binding/input-output.md
+++ b/src/articles/data-binding/input-output.md
@@ -62,7 +62,7 @@ import { CommonModule } from "@angular/common";
   styleUrl: "./app.component.scss",
 })
 export class AppComponent {
-  messages = ["The first message", "The seco nd message"];
+  messages = ["The first message", "The second message"];
 }
 ```
 
@@ -79,7 +79,7 @@ export class AppComponent {
 ვაბამთ `messages` მასივში არსებულ მეორე სტრინგს. `message` ფროფერთი app-child-ზე
 მშობელი კომპონენტიდან ხელმისაწვდომია სწორედ `@Input()` დეკორატორის წყალობით.
 ასე child კომპონენტი თავის კლასში იმავე სახელის message თვისებაზე მიიღებს მშობელი
-ელემენტიდამ მიწოდებულ მნიშვნელობას, და მას თემფლეითში განათავსებს.
+ელემენტიდან მიწოდებულ მნიშვნელობას, და მას თემფლეითში განათავსებს.
 
 ტაიპსკრიპტის წყალობით ეს ფროფერთი მხოლოდ კონკრეტული ტიპის მონაცემს მიიღებს,
 ანუ თუ ჩვენ `message` ფროფერთიზე სხვა ტიპის მნიშვნელობას მივაბამთ, ეს გამოიწვევს
diff --git a/src/articles/data-binding/property-and-attribute-binding.md b/src/articles/data-binding/property-and-attribute-binding.md
index b347d7a..8ae941d 100644
--- a/src/articles/data-binding/property-and-attribute-binding.md
+++ b/src/articles/data-binding/property-and-attribute-binding.md
@@ -51,7 +51,7 @@ export class AppComponent {
 }
 ```
 
-თი გვსურს რომ `imgData` ობიექტში არსებული `src` და `alt` თვისებათა მნიშვნელობები
+თუ გვსურს რომ `imgData` ობიექტში არსებული `src` და `alt` თვისებათა მნიშვნელობები
 მივაბათ თემფლეითში არსებულ `img` ელემენტს, მაშინ ელემენტზე არსებულ ატრიბუტს ვაქცევთ
 ოთკუთხედ ფრჩხილებში და ტოლობის შემდეგ ვწერთ იმ ცვლადებს, რომლებიც კლასსში არსებობს.
 ახლა რაღაც თვალსაზრისით, ბრჭყალებში ტაიპსკრიპტის/ჯავასკრიპტის ექსფრეშენები (expressions) მუშაობს.
@@ -97,8 +97,8 @@ HTML-ში ერთი შეხედვით ელემენტის 
 და იგივე მნიშვნელობები არ ჰქონდეთ.
 
 უშუალოდ HTML-ის ელემენტების ატრიბუტის მოდიფიკაციისთვის, ისევე როგორც ფროფერთი ბაინდინგის
-შემთხვევაშია, ატრიბუტის სახელს ოთხკუთხედ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსა
-და წერტილს, ხოლო ტოლობის შემდეგ ბრჭყალებში უნდა დაიწეროს ქსფრეშენი, რომელის სტრინგწს აბრუნებს:
+შემთხვევაშია, ატრიბუტის სახელს ოთხკუთხედ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსსა
+და წერტილს, ხოლო ტოლობის შემდეგ ბრჭყალებში უნდა დაიწეროს ექსფრეშენი, რომელის სტრინგს აბრუნებს:
 
 ```html
 <button
diff --git a/src/articles/data-binding/two-way-binding.md b/src/articles/data-binding/two-way-binding.md
index d57aae6..457f810 100644
--- a/src/articles/data-binding/two-way-binding.md
+++ b/src/articles/data-binding/two-way-binding.md
@@ -98,9 +98,9 @@ fontSizePx = 16;
 <div [style.font-size.px]="fontSizePx">Resizable Text</div>
 ```
 
-რაც ზუსტად იგივეს აკეტებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
+რაც ზუსტად იგივეს აკეთებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
 სწორედ ეს არის two way binding. ეს შესაძლებელია მხოლოდ იმ შემთხვევასი, თუ იმ კომპონენტში, რომელზეც
-ჩვენ ბაინდინგს ვაკეტებთ `Input`-ისა და `Output` თვისებების სახელები კონკრეტული კონვენციითაა შექმნილი:
+ჩვენ ბაინდინგს ვაკეთებთ `Input`-ისა და `Output` თვისებების სახელები კონკრეტული კონვენციითაა შექმნილი:
 `Output` თვისება უნდა იწყებოდეს `Input` თვისების დასახელებით და ბოლოში უნდა ემატებოდეს `Change`.
 
 ```ts

From 8256a85b47d28650744c45ef1092e0bad1e2468d Mon Sep 17 00:00:00 2001
From: Mari-Gogolashvili <133369792+Mari-Gogolashvili@users.noreply.github.com>
Date: Sun, 18 Feb 2024 22:31:26 +0400
Subject: [PATCH 2/2] .

---
 src/articles/control-flow/index.md                 |  6 +++---
 src/articles/data-binding/input-output.md          |  6 +++---
 .../data-binding/property-and-attribute-binding.md |  4 ++--
 src/articles/data-binding/two-way-binding.md       | 12 ++++++------
 .../dependency-injection/di-in-angular/index.md    |  2 +-
 .../dependency-injection/di-in-angular/with-di.md  | 10 +++++-----
 src/articles/dependency-injection/di-in-general.md |  4 ++--
 src/articles/directives/attribute-directives.md    |  4 ++--
 src/articles/directives/creating-directive.md      | 12 ++++++------
 src/articles/directives/structural-directives.md   |  8 ++++----
 src/articles/forms/reactive.md                     | 10 +++++-----
 src/articles/forms/template-driven.md              |  8 ++++----
 .../forms/validation/built-in-validators.md        |  2 +-
 .../forms/validation/validation-messages.md        |  2 +-
 src/articles/introduction/creating-component.md    |  2 +-
 .../introduction/interpolation-data-binding.md     |  2 +-
 src/articles/pipes/built-in-pipes.md               | 10 +++++-----
 src/articles/pipes/creating-pipe.md                | 14 +++++++-------
 18 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/articles/control-flow/index.md b/src/articles/control-flow/index.md
index fea7e2e..ce2f155 100644
--- a/src/articles/control-flow/index.md
+++ b/src/articles/control-flow/index.md
@@ -6,11 +6,11 @@ title: "Control Flow"
 
 ანგულარის მე-17 ვერსიიდან საშუალება გვაქვს, რომ [სტრუქტურული დირექტივების](/directives/structural-directives.html)
 მაგივრად გამოვიყენოთ ახალი control flow სინტაქსი, რომლითაც ვმართავთ თემფლეითში
-_რა_ უნდა გამოჩდეს და _როგორ_ უნდა გამოჩნდეს. ამ სინტაქსის ქივორდები `@` სიმბოლოთი იწყება
+რა უნდა გამოჩდეს და როგორ უნდა გამოჩნდეს. ამ სინტაქსის ქივორდები `@` სიმბოლოთი იწყება
 და ძალიან ჰგავს ჯავასკრიპტის სტანდარტული `if/else/switch/for` სინტაქსს.
 
 გაითვალისწინეთ, რომ ეს control-flow არის development preview-ში. ანუ ანგუალრის ახალ
-ვერსიებში მისი გამოყენების და ფუნქციონირების სპეციფიკა შეიძლება შეიცვალოს.
+ვერსიებში მისი გამოყენებისა და ფუნქციონირების სპეციფიკა შეიძლება შეიცვალოს.
 
 ## `@if` ბლოკი
 
@@ -95,7 +95,7 @@ items = [
  }
 ```
 
-### `$index` და სხვა იპმლიციტური ცვლადები
+### `$index` და სხვა იმპლიციტური ცვლადები
 
 `@for` ბლოკის შიგნით საშუალება გვაქვს გამოვიყენოთ იმპლიციტური ცვლადები,
 რომელსაც ანგულარი ლუპში გვაწვდის, მაგალითად `$index`:
diff --git a/src/articles/data-binding/input-output.md b/src/articles/data-binding/input-output.md
index 2df3e14..d5309ef 100644
--- a/src/articles/data-binding/input-output.md
+++ b/src/articles/data-binding/input-output.md
@@ -136,7 +136,7 @@ export class ChildComponent {
 ტიპი უნდა შევფუთოთ. მარტივად რომ ვთქვათ, ტაიპსკრიპტმა იცის, რომ `EventEmitter` რაღაც
 მოვლენას გასცემს, თუმცა არ იცის ეს მოვლენა შედეგად რა ტიპის მნიშვნელობას გვაძლევს.
 რადგან ჩვენ რიცხვობრივი მნიშვნელობის გადაცემა გვინდა, ამიტომ
-ჩვენ მეტობა-ნაკლებობა ნიშნებს შორის ვწერთ `number` ტიპს, რათა დავაზუსტოთ, რომ `EventEmiter`
+ჩვენ კუთხურ ფრჩხილებს შორის ვწერთ `number` ტიპს, რათა დავაზუსტოთ, რომ `EventEmiter`
 `number` ტიპის მნიშვნელობას გადასცემს მშობელს.
 
 `onCount` მეთოდში `EventEmitter`-ის ინსტანციაზე, ანუ `lengthCount`-ზე დავუძახებთ `emit` მეთოდს,
@@ -235,5 +235,5 @@ export class ChildComponent implements OnChanges {
 შვილ კომპონენტს გადავცემთ მნიშვნელობას მშობელი კომპონენტიდან, ხოლო `Output` დეკორატორის
 საშუალებით შვილ კომპონენტზე ვქმნით ივენთის ემითერს, რომელიც კონკრეტულ მნიშვნელობებს
 აემითებს. შვილის ივენთ ემითერს ჩვენ შეგვიძლია მშობელი ელემენტიდან მოვუსმინოთ და მოვიხელთოთ
-დაემითებული მნიშვნელობები `$event`-ის საშუალებით. ჩვენ ასევე შეგვიძლია ვირეაგიროთ მშობლიდან
-შვილზე ჩამოწოდებული მონაცემების ცვლილებებზე `ngOnChanges` ჰუკით.
+დაემითებული მნიშვნელობები `$event`-ის საშუალებით. ჩვენ ასევე შეგვიძლია ვირეაგიროთ მშობლისგან
+მოწოდებული მონაცემების ცვლილებებზე `ngOnChanges` ჰუკით.
diff --git a/src/articles/data-binding/property-and-attribute-binding.md b/src/articles/data-binding/property-and-attribute-binding.md
index 8ae941d..bfd8273 100644
--- a/src/articles/data-binding/property-and-attribute-binding.md
+++ b/src/articles/data-binding/property-and-attribute-binding.md
@@ -53,7 +53,7 @@ export class AppComponent {
 
 თუ გვსურს რომ `imgData` ობიექტში არსებული `src` და `alt` თვისებათა მნიშვნელობები
 მივაბათ თემფლეითში არსებულ `img` ელემენტს, მაშინ ელემენტზე არსებულ ატრიბუტს ვაქცევთ
-ოთკუთხედ ფრჩხილებში და ტოლობის შემდეგ ვწერთ იმ ცვლადებს, რომლებიც კლასსში არსებობს.
+კვადრატულ ფრჩხილებში და ტოლობის შემდეგ ვწერთ იმ ცვლადებს, რომლებიც კლასში არსებობს.
 ახლა რაღაც თვალსაზრისით, ბრჭყალებში ტაიპსკრიპტის/ჯავასკრიპტის ექსფრეშენები (expressions) მუშაობს.
 
 ```html
@@ -97,7 +97,7 @@ HTML-ში ერთი შეხედვით ელემენტის 
 და იგივე მნიშვნელობები არ ჰქონდეთ.
 
 უშუალოდ HTML-ის ელემენტების ატრიბუტის მოდიფიკაციისთვის, ისევე როგორც ფროფერთი ბაინდინგის
-შემთხვევაშია, ატრიბუტის სახელს ოთხკუთხედ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსსა
+შემთხვევაშია, ატრიბუტის სახელს კვადრატულ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსსა
 და წერტილს, ხოლო ტოლობის შემდეგ ბრჭყალებში უნდა დაიწეროს ექსფრეშენი, რომელის სტრინგს აბრუნებს:
 
 ```html
diff --git a/src/articles/data-binding/two-way-binding.md b/src/articles/data-binding/two-way-binding.md
index 457f810..3290e53 100644
--- a/src/articles/data-binding/two-way-binding.md
+++ b/src/articles/data-binding/two-way-binding.md
@@ -15,7 +15,7 @@ Two way binding გულისხმობს property binding-ისა და
 ng g c sizer
 ```
 
-sizer კომპონენტი მარტივი პრინციპით იმუშავებს. ის მშობელისგან მიიღებს საწყის ფონტის ზომას
+sizer კომპონენტი მარტივი პრინციპით იმუშავებს. ის მშობლისგან მიიღებს საწყისი ფონტის ზომას
 (`@Input() size`),
 ხოლო თვითონ, ღილაკზე დაჭერის საფუძველზე ამ ფონტის ზომას გაზრდის და ისე გადასცემს მშობელს
 (`@Output() sizeChange`).
@@ -83,12 +83,12 @@ fontSizePx = 16;
 ახლა ფონტის ზომა უნდა იცვლებოდეს. აპლიკაციაში შემდეგი რამ ხდება:
 
 - თავდაპირველად, როცა აპლიკაცია იტვირთება, `AppComponent`-ში არსებული `fontSizePx`
-  გადაეცემა `SizerComponent`, რომელიც ინიციალიზაციისას სწორედ მის მნიშვნელობას შეინახავს
+  გადაეცემა `SizerComponent`, რომელიც ინიციალიზაციისას მის მნიშვნელობას შეინახავს
   `size` თვისებაში. სწორედ ამ ზომას გამოსახავს ეს კომპონენტი.
 - `SizerComponent`-ში ღილაკზე დაჭერით გააქტიურდება `dec` ან `inc` მეთოდი, რომელიც `resize` მეთოდს
-  დაუძახებს და შეცვლის ფონტის ზომას, ამასთანავე დააემითებს ამ ახალ ზომას.
+  დაუძახებს და შეცვლის ფონტის ზომას, ამასთანავე დააემითებს ახალ ზომას.
 - ახალ დაემითებულ ზომას `AppComponent` ივენთ ბაინდინგის საშუალებით დააფიქსირებს და შეცვლის თავის
-  ფროფერთის `fontSizePx` რათა მან ეს ახალი მნიშვნელობა მიიღოს.
+  ფროფერთის `fontSizePx` , რათა მან ეს ახალი მნიშვნელობა მიიღოს.
 - შედეგად იცვლება `AppComponent`-ის თემფლეითში არსებული ტექსტის ზომა.
 
 ამ ბაინდინგის შესამოკლებლად ანგულარში შექმნეს შემდეგნაირი სინტაქსი:
@@ -98,8 +98,8 @@ fontSizePx = 16;
 <div [style.font-size.px]="fontSizePx">Resizable Text</div>
 ```
 
-რაც ზუსტად იგივეს აკეთებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
-სწორედ ეს არის two way binding. ეს შესაძლებელია მხოლოდ იმ შემთხვევასი, თუ იმ კომპონენტში, რომელზეც
+რაც ზუსტად იმავეს აკეთებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
+სწორედ ეს არის two way binding. ეს შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ იმ კომპონენტში, რომელზეც
 ჩვენ ბაინდინგს ვაკეთებთ `Input`-ისა და `Output` თვისებების სახელები კონკრეტული კონვენციითაა შექმნილი:
 `Output` თვისება უნდა იწყებოდეს `Input` თვისების დასახელებით და ბოლოში უნდა ემატებოდეს `Change`.
 
diff --git a/src/articles/dependency-injection/di-in-angular/index.md b/src/articles/dependency-injection/di-in-angular/index.md
index 754e42d..eee8a1d 100644
--- a/src/articles/dependency-injection/di-in-angular/index.md
+++ b/src/articles/dependency-injection/di-in-angular/index.md
@@ -10,5 +10,5 @@ title: "DI ანგულარში"
 ამ თავში:
 
 - [მოვამზადებთ პატარა პროექტს](./initial-setup.html);
-- სდაც ჯერ ავაწყობთ აპლიკაციას [DI-ს გარეშე](./without-di.html);
+- სადაც ჯერ ავაწყობთ აპლიკაციას [DI-ს გარეშე](./without-di.html);
 - ხოლო შემდეგ [DI-ს გამოყენებით](./with-di.html).
diff --git a/src/articles/dependency-injection/di-in-angular/with-di.md b/src/articles/dependency-injection/di-in-angular/with-di.md
index 9f7e339..5c10407 100644
--- a/src/articles/dependency-injection/di-in-angular/with-di.md
+++ b/src/articles/dependency-injection/di-in-angular/with-di.md
@@ -5,7 +5,7 @@ title: "DI-ის გამოყენებით"
 # DI-ის გამოყენებით
 
 ვთქვათ ეს ორი შვილი კომპონენტი გახდა კომპლექსური. მათ ბევრი ცალკეული
-შვილი კომპონენტი ჰყავთ, რომლებსაც მენეჯმენტი უნდა გაუკეთონ. ლოგიკის რაღაც ნაწილი,
+შვილი კომპონენტი ჰყავთ, რომლებიც უნდა დაამენეჯმენტონ. ლოგიკის რაღაც ნაწილი,
 კერძოდ გმირებზე ინფორმაციის მანიპულაცია ძალიან განმეორებადი იქნებოდა თითოეულ
 კომპონენტში. ამ კომპონენტებს ისევ პრიმიტიულად დავტოვებთ, მაგრამ გამოვიყენებთ
 სერვისებს, რაც ჩვენი გმირების შესახებ ინფორმაციასთან დაკავშირებულ ლოგიკას
@@ -104,7 +104,7 @@ import { HeroService } from './hero.service.ts'
 })
 ```
 
-თუ მხოლოდ კონკრეუტლი კომპონენტებისთვის გვინდა ეს კლასი, მაშინ სეგვიძლია
+თუ მხოლოდ კონკრეუტლი კომპონენტებისთვის გვინდა ეს კლასი, მაშინ შეგვიძლია
 `Component` დეკორატორში მისი `providers` მასივში დამატებაც:
 
 ```ts
@@ -116,7 +116,7 @@ import { HeroService } from './hero.service.ts'
 ```
 
 ასე ანგულარი `HeroService`-ის უნიკალურ ინსტანციას შექმნის
-_მხოლოდ `AppComponent`-ისთვის_.
+მხოლოდ `AppComponent`-ისთვის.
 
 ამ შემთხვევაში ჩვენ`{providedIn: 'root'}`-ს დავტოვებთ. ანუ ეს
 სერვისი იქნება ე.წ "Singleton" სერვისი, სადაც მისი ერთი ინსტანცია
@@ -253,9 +253,9 @@ export class HeroDetailsComponent {
 აქ სტრიმები პირობითია. მთავარია დავინახოთ სერვისების ეფექტურობა: მათი საშუალებით გმირებთან
 დაკავშირებული ლოგიკა ერთ ადგილას გავაერთიანეთ და მასზე გავხადეთ დამოკიდებული ორი
 კომპონენტი. ეს ორივე კომპონენტი `HeroService`-ის ერთსა და იმავე ინსტანციას იყენებენ,
-და ასე ვთქვათ ერთმანეთთან სინქრონიზირებულები არიან. ორივეს შეუძლია არსებული გმირების
+და ასე ვთქვათ ერთმანეთთან სინქრონიზებულები არიან. ორივეს შეუძლია არსებული გმირების
 სიისა და არჩეული გმირის შესახებ ინფორმაციის აღება ან მასზე რეაგირება.
 
 ანგულარის უნიკალურობა სწორედ ამაში მდგომარეობს, dependency injection მისი უდიდესი
-პლიუსია. DI-ით უფრო მეტი საინტერესო რაღაცების გაკეთება შეიძლება,
+პლუსია. DI-ით უფრო მეტი საინტერესო რაღაცების გაკეთება შეიძლება,
 [გაეცანით ოფიციალურ დოკუმენტაციას](https://angular.dev/guide/di).
diff --git a/src/articles/dependency-injection/di-in-general.md b/src/articles/dependency-injection/di-in-general.md
index 90ec2b2..79e2598 100644
--- a/src/articles/dependency-injection/di-in-general.md
+++ b/src/articles/dependency-injection/di-in-general.md
@@ -41,7 +41,7 @@ class Soldier {
 }
 ```
 
-ასეთ კოდში მკაფიოდ არ ჩანს, რომ `Soldier` კლასს სჭირდება `General`. ეს მიტუმეტეს გაუგებარი
+ასეთ კოდში მკაფიოდ არ ჩანს, რომ `Soldier` კლასს სჭირდება `General`. ეს უფრო გაუგებარი
 იქნებოდა, თუ თითოეული კლასი ცალკეულ დიდ და კომპლექსურ ფაილში გვექნებოდა. როცა
 ჩვენ `Soldier` კლასის ინსტანციას შევქმნიდით, არავის ეცოდინებოდა, რომ ამ კლასს სჭირდებოდა
 `General` კლასი. მისი ინსტანცია შეიქმნება, მაგრამ ეს უკანა ფონზე, ჩუმად მოხდება.
@@ -89,7 +89,7 @@ const soldier3 = new Soldier(general);
 ერთი მხრივ, ახლა მკაფიოა, რომ `Soldier`-ს სჭირდება `General`, მაგრამ მეორე მხრივ,
 ყოველ `Soldier`-ს ერთი და იგივე `General`-ის ინსტანცია აქვს. ასე ვთქვათ, ამ ჯარისკაცებს
 ერთი გენერალი მართავს, რომლის ინსტანციაც ჩვენ თავდაპირველად შევქმენით, და თითოეულ
-ჯარისკაცს მივაწოდეთ კონსტრუქტორში. ეს ასევე ბეფრად უფრო ეკონომიურია, რადგან ტყუილად
+ჯარისკაცს მივაწოდეთ კონსტრუქტორში. ეს ასევე ბევრად უფრო ეკონომიურია, რადგან ტყუილად
 არ ვქმნით იმდენივე `General`-ის ინსტანციას, რამდენი `Soldier`-იც დაგვჭირდება.
 
 ახლა ეს შედეგად მოგვცემს true-ს
diff --git a/src/articles/directives/attribute-directives.md b/src/articles/directives/attribute-directives.md
index a7ca6f2..b85a6c0 100644
--- a/src/articles/directives/attribute-directives.md
+++ b/src/articles/directives/attribute-directives.md
@@ -80,7 +80,7 @@ import { FormsModule } from "@angular/forms";
 export class AppComponent {}
 ```
 
-`NgModel` ფორმის ელემენტებზე გამოიყენება two way binding-ით.
+`NgModel` ფორმის ელემენტებზე გამოიყენება two-way binding-ით.
 დავუშვათ, რომ კომპონენტის კლასში გვაქვს ინიციალიზებული თვისება
 title.
 
@@ -100,6 +100,6 @@ title.
 
 ამ თავში ჩვენ განვიხილეთ `NgClass` და `NgModel` ატრიბუტ დირექტივები.
 `NgClass` ელემენტს უცვლის კლასს გარკვეული პირობების მიხედვით, ხოლო
-`NgModel` input ელემენტზე თავსდება two way binding-ით, რაც საშუალებას
+`NgModel` input ელემენტზე თავსდება two-way binding-ით, რაც საშუალებას
 გვაძლევს, რომ ფორმის ელემენტებს ინფორმაცია გადავცეთ და მათგან
 ავიღოთ მომხმარებლის მიერ შეყვანილი ინფორმაცია.
diff --git a/src/articles/directives/creating-directive.md b/src/articles/directives/creating-directive.md
index 8d5a724..28dd783 100644
--- a/src/articles/directives/creating-directive.md
+++ b/src/articles/directives/creating-directive.md
@@ -30,10 +30,10 @@ export class HighlightDirective {
 }
 ```
 
-ეს კლასი შესაბამისი მოდულის დეკლარაციების სიაშიუნდა იყოს დამატებული, რათა ანგულარმა მისი არსებობის შესახებ იცოდეს.
+ეს კლასი შესაბამისი მოდულის დეკლარაციების სიაში უნდა იყოს დამატებული, რათა ანგულარმა მისი არსებობის შესახებ იცოდეს.
 `Directive` დეკორატორში ჩვენ შეგვიძლია დირექტივის კონფიგურაცია. არსებობს სხვადასხვაგვარი სელექტორი და იმის
 მიხედვით თუ რა სელექტორს ავირჩევთ, ანგულარი განსხვავებული პრინციპით გაუკეთებს ამ დირექტივს ინიციალიზაციას.
-ოთკუთხედ ბრჭყალებში მოქცეული სახელი გულისხმობს, რომ ჩვენ დირექტივის გამოყენება ატრიბუტის სახელით შეგვიძლია
+ ბრჭყალების შიგნით, კვადრატულ ფრჩხილებში მოქცეული სახელი გულისხმობს, რომ ჩვენ დირექტივის გამოყენება ატრიბუტის სახელით შეგვიძლია
 რაიმე ელემენტზე:
 
 ```html
@@ -73,7 +73,7 @@ export class HighlightDirective {
 როცა ჩვენ ელემენტზე მოვათავსებთ `appHighlight` დირექტივს, მასზე იმუშავებს ამ დირექტივის კლასში
 არსებული ლოგიკა. ანუ `Input` დეკორატორით შექმნილი თვისება არსებულ ელემენტზე შესაძლებელია
 მიებას მშობელი ელემენტიდან data binding-ით. `highlightColor`-ში რამდენიმე შესაძლო მნიშვნელობის
-ტიპი განსვსაზღვრეთ და წინასწარი ფერიც დავუწერეთ.
+ტიპი განვსაზღვრეთ და წინასწარი ფერიც დავუწერეთ.
 
 კონსტრუქტორში შემოგვაქვს `ElementRef`, იგი იმ native ელემენტზე გვაძლევს წვდომას, რომელზეც
 ეს დირექტივი იჯდება. მას host ელემენტი ჰქვია. `ElementRef`-ის საშუალებით `HostListener`-ებში გარკვეული მოვლენების
@@ -84,7 +84,7 @@ export class HighlightDirective {
 `mouseover` მოვლენის შემთხვევაში ელემენტს ჩვენთვის სასურველი ფერი მიენიჭება,
 ხოლო როცა მაუსი მის არეალს დატოვებს, ფერი საწყის მდგომარეობას დაუბრუნდება.
 
-`HilightDirective` არის standalone ტიპის დირექტივი, რაც იმას ნიშნავს, რომ მის გამოსაყენებლად საჭიროა
+`HighlightDirective` არის standalone ტიპის დირექტივი, რაც იმას ნიშნავს, რომ მის გამოსაყენებლად საჭიროა
 ამ კლასის დამატება კომპონენტის იმპორტების სიაში. ჩვენ ამ დირექტივს `AppComponent`-ში ვიყენებთ.
 
 ```ts
@@ -112,8 +112,8 @@ export class AppComponent {}
 ```
 
 ახლა პირველ ორ სათაურს ფერი უნდა ეცვლებოდეს. ყურადღება მიაქციეთ, რომ `highlightColor` თვისებაზე
-ჩვენ ოთკუთხედი ფრჩხილები არ გამოვიყენეთ. ასე `highlightColor` თვისება დირექტივის კლასში იღებს პირდაპირ
-სტრინგის ტიპის მნიშვნელობას. ოთხკუთხედი ფრჩხილებით `blue` არა სტრინგი, არამედ ცვლადის სახელი იქნებოდა,
+ჩვენ კვადრატული ფრჩხილები არ გამოვიყენეთ. ასე `highlightColor` თვისება დირექტივის კლასში იღებს პირდაპირ
+სტრინგის ტიპის მნიშვნელობას. კვადრატული ფრჩხილებით `blue` არა სტრინგი, არამედ ცვლადის სახელი იქნებოდა,
 როგორც ჯავასკრიპტის ექსპფრეშენი, ამისთვის სათანადო სახელის თვისება უნდა არსებობდეს `AppComponent`-ის კლასში.
 
 შესაძლებელია დირექტივში არსებობდეს სელექტორის სახელის მქონე `Input` თვისება:
diff --git a/src/articles/directives/structural-directives.md b/src/articles/directives/structural-directives.md
index e52609b..299c334 100644
--- a/src/articles/directives/structural-directives.md
+++ b/src/articles/directives/structural-directives.md
@@ -25,8 +25,8 @@ title: "Structural Directives"
 ```
 
 კომპონენტის კლასში გვაქვს `isActive` თვისება, რომლის მნიშვნელობაც არსებულის
-საპირისპირო ხდება ღილაკზე დაჭერისას. `NgIf` დირექტივში მიწოდებული ექსფრეშენი
-მაშასადამე იცვლება და ეს კომპონენტს აჩენს ან აქრობს. კომპონენტის შემთხვევაში
+საპირისპირო ხდება ღილაკზე დაჭერისას. `NgIf` დირექტივში მიწოდებული ექსფრეშენი,
+მაშასადამე, იცვლება და ეს კომპონენტს აჩენს ან აქრობს. კომპონენტის შემთხვევაში
 `NgIf` დირექტივი მეხსიერებიდან მთლიანად შლის კოპმონენტს და მასში არსებულ
 შვილებს მთელი თავისი მონაცემებით, რათა მეხსიერება გათავისუფლდეს.
 აქედან გამომდინარე, გაჩენის შემთხვევაში host კომპონენტი ხელახლა იქმნება.
@@ -45,7 +45,7 @@ title: "Structural Directives"
 
 აქ ყოველ იტერაციაზე item ცვლადში ინახება items მასივში არსებული ელემენტი,
 რომელიც გადაეცემა host კომპონენტს.
-`NgFor` ის host ბლოკში ეს ცვლადი ყველგან არის ხელმისაწვდომი.
+`NgFor`-ის host ბლოკში ეს ცვლადი ყველგან არის ხელმისაწვდომი.
 
 ```html
 <div *ngFor="let item of items">
@@ -69,7 +69,7 @@ itemTrackBy(index, item) {
 ამ ფუნქციამ უნდა დააბრუნოს ობიექტის რაიმე უნიკალური თვისება, რომლითაც ანგულარი
 ამ ობიექტებს ერთმანეთისგან გაარჩევს.
 
-შემდეგ თემფლეითში, `NgFor` დირექტივში `;`-ით გამოვწყოფთ ახალ ექსფრეშენს
+შემდეგ თემფლეითში, `NgFor` დირექტივში `;`-ით გამოვყოფთ ახალ ექსფრეშენს
 და ვამატებთ ამ ფუნქციას `trackBy`-ს არგუმენტად:
 
 ```html
diff --git a/src/articles/forms/reactive.md b/src/articles/forms/reactive.md
index 9023efb..f679a5f 100644
--- a/src/articles/forms/reactive.md
+++ b/src/articles/forms/reactive.md
@@ -10,7 +10,7 @@ title: "Reactive Forms"
 
 ## მარტივი კონტროლი
 
-სასრულველ კომპონენტში, სადაც ფორმა გვექნება, ჩვენ უნდა შევქმნათ
+სასურველ კომპონენტში, სადაც ფორმა გვექნება, ჩვენ უნდა შევქმნათ
 კონტროლები. შესაძლებელია თითოეული ველისთვის `FormControl` ინსტანციის შექმნა.
 აქ ჩვენ კოპმონენტში ვქმნით ახალ კონტროლს, სადაც მომხმარებლის სახელს შევინახავთ.
 
@@ -48,7 +48,7 @@ export class SignupFormComponent {
 ```
 
 დანარჩენს ანგულარი თავისით აგვარებს და კონტროლის თვისებებს მოდიფიკაციას
-უკეთეს შეყვანილი მნიშვნელობების მიხედვით. შეყვანილ მნიშვნელობის სნეპშოტს ვწვდებით
+უკეთებს შეყვანილი მნიშვნელობების მიხედვით. შეყვანილ მნიშვნელობის სნეპშოტს ვწვდებით
 კონტროლზე `value` თვისებით, რომელსაც გამოვსახავთ თემფლეითში.
 
 ### კონტროლთა ჯგუფი
@@ -191,7 +191,7 @@ export class SignupFormComponent {
 
 აქ ჩვენ `password` გამოვტოვეთ, თუმცა ამის გამო პრობლემა არ შეგვექმნება.
 
-დასაბმითებისას ხშირა ფორმის დაცარიელება ხოლმე. ამისთვის შეგვიძლია ჯგუფზე
+დასაბმითებისას ხშირია ფორმის დაცარიელება. ამისთვის შეგვიძლია ჯგუფზე
 ან კონტროლებზე `reset` მეთოდის დაძახება.
 
 ```ts
@@ -251,7 +251,7 @@ export class SignupFormComponent {
 მასივში ვატანთ ბილდერით შექმნილ კონტროლს. თავდაპირველად გვქონდეს მხოლოდ
 ერთი კონტროლი.
 
-აქვე getter მეთოდს ვქმნით რათა `positions`-ის კონტროლებს უფრო მოკლედ და მარტივად ჩავწვდეთ.
+აქვე getter მეთოდს ვქმნით, რათა `positions`-ის კონტროლებს უფრო მოკლედ და მარტივად ჩავწვდეთ.
 ანუ როცა ჩვენ `positions`-ს გამოვიყენებთ, ეს სინამდვილეში იქნება `this.signupForm.controls["positions"]`.
 ჩვენ დაგვჭირდება მეთოდი, რომლის საშუალებითაც ამ მასივს ახალი კონტროლი დაემატება. სწორედ ამას
 აკეთებს `addPosition` მეთოდი. იგი არსებული კონტროლების მასივს ახალი კონტროლის ისნტანციას ამატებს.
@@ -274,7 +274,7 @@ export class SignupFormComponent {
 გაითვალისწინეთ, რომ positions არის signupForm-ის წევრი. აქ `formArrayName`-ის საშუალებით
 რაიმე მშობელ კონტეინერზე სათანადო მასივის სახელს ვუთითებთ. ახლა ანგულარმა იცის, რომ
 ამ ბლოკში `positions` ველში არსებულ კონტროლებთან გვაქვს საქმე. ჩვენ `NgFor` დირექტივით
-ვლუპავთ პოზიციის კონტროლებზე და თითოეული პოზიციისთვის ვიღებთ ინდექსს, რომელსაც
+ვლუპავთ პოზიციის კონტროლებს და თითოეული პოზიციისთვის ვიღებთ ინდექსს, რომელსაც
 ფროფერთი ბაინდინგით ვაკავშირებთ `formControlName`-ზე. `FormArray`-ში კონტროლის სახელი
 მასივის ინდექსია. + ღილაკზე დაჭერით ახალი კონტროლი იქმნება და შესაბამისად ახალი ველიც გამოჩნდება.
 მათი მნიშვნელობებს ქვემოთაც დავინახავთ, სადაც ფორმის მნიშვნელობას გამოვსახავთ.
diff --git a/src/articles/forms/template-driven.md b/src/articles/forms/template-driven.md
index 578c2b4..4818455 100644
--- a/src/articles/forms/template-driven.md
+++ b/src/articles/forms/template-driven.md
@@ -16,7 +16,7 @@ template-driven ფორმები ეყრდნობიან `FormsModul
 
 ## ფორმის აწყობა
 
-ვთქვათ, გვინდა ფორმის აწყობა, სადაც ვეფხისტყაოსნის გმირებს
+ვთქვათ, გვინდა ფორმის აწყობა, სადაც ,,ვეფხისტყაოსნის" გმირებს
 დარეგისტრირება შეეძლებათ ახალი თავგადასავლის დასაწყებად,
 და სადაც ასევე შეძლებენ თანამგზავრი მეგობრის არჩევას.
 
@@ -131,7 +131,7 @@ export class HeroFormComponent {
 
 ახლა ღილაკზე დაჭერისას უნდა გამოჩნდეს შედეგი, რაც ადასტურებს იმას, რომ
 შეყვანილ მონაცემებს სწორად ვინახავთ. იდეაში ღილაკზე დაჭერის შემდეგ
-ჩვენ რაიმე HTTP მოთხოვნა უნდ აგავაგზავნოთ, თუმცა ახლა შედეგს უბრალოდ
+ჩვენ რაიმე HTTP მოთხოვნა უნდა გავაგზავნოთ, თუმცა ახლა შედეგს უბრალოდ
 თემფლეითში გამოვსახავთ.
 
 ### ვალიდაცია
@@ -205,10 +205,10 @@ export class HeroFormComponent {
 რომ თუ ფორმა ცარიელია, მაშინ ის არავალიდურია და სათანადო კონტროლს ანიჭებს `invalid`
 თვისებაზე true-ს, ხოლო `valid` თვისებაზე false-ს. ამ თვისებებს მსგავსი პრინციპით ვიღებთ:
 ლოკალურ ცვლადს ვქმნით და მას ვუტოლებთ `ngModel`-ს. ასე ჩვენ ცვლადებში `FormControl`-ის
-ისნტანციას ვინახავთ, რომელსაც გარკვეული თვისებები გააჩნია. თუ კონტროლი არავალიდურია, ჩვენ
+ინსტანციას ვინახავთ, რომელსაც გარკვეული თვისებები გააჩნია. თუ კონტროლი არავალიდურია, ჩვენ
 გვინდა რომ თითოეული ველის ქვეშ ამის შესახებ მინიშნება გამოჩნდეს. მაგრამ ეს მინიშნება არ გვინდა,
 რომ თავიდანვე ხილვადი იყოს, ფორმა კი თავიდან არავალიდურია. სწორედ ამიტომ ასევე ვიყენებთ
-`pristine` ცვლადს. ეს ნიშნავს, რომ მომხმარებელს ჯერ არეფერი შეუყვანია ველში. ჩვენ
+`pristine` ცვლადს. ეს ნიშნავს, რომ მომხმარებელს ჯერ არაფერი შეუყვანია ველში. ჩვენ
 მინიშნება მაშინ გვინდა გამოვაჩინოთ, როცა კონტროლი არავალიდურია და მასში ცვლილება
 უკვე შეტანილი იყო. `pristine`-ის საპირისპირო თვისებაც არსებობს -- `dirty`, რომელიც შეგვიძლია
 გამოვიყენოთ ამ პირველის ნეგაციის მაგივრად.
diff --git a/src/articles/forms/validation/built-in-validators.md b/src/articles/forms/validation/built-in-validators.md
index d88f4b7..9030f09 100644
--- a/src/articles/forms/validation/built-in-validators.md
+++ b/src/articles/forms/validation/built-in-validators.md
@@ -57,7 +57,7 @@ export class SignupFormComponent {
 </div>
 ```
 
-ვალიდატორებს ჩვენ ფორმის კონტროლის შექმნისას ვარეგისტრირებთ. ვაიმპორტებთ
+ვალიდატორებს ფორმის კონტროლის შექმნისას ვარეგისტრირებთ. ვაიმპორტებთ
 `Validators` კლასს, და აქედან ვარჩევთ სასურველ ვალიდატორს:
 
 ```ts
diff --git a/src/articles/forms/validation/validation-messages.md b/src/articles/forms/validation/validation-messages.md
index a8b5029..60bb9f3 100644
--- a/src/articles/forms/validation/validation-messages.md
+++ b/src/articles/forms/validation/validation-messages.md
@@ -57,7 +57,7 @@ title: "ვალიდაციის მესიჯები"
 
 აქვე სახელის ველში კონტროლის ერორებს ვწვდებით. ეს ერორები მაშინ ჩნდება,
 როცა ვალიდატორებში ვაბრუნებთ ერორებს. ცუდი სახელის პატერნის შემთხვევვაში
-ეს ერორი იარსებებს და შესაბამისად ჩვენ მას შეგვიძლია ჩავწვდეთ და ის მესიჯი
+ეს ერორი იარსებებს და შესაბამისად შეგვიძლია მას  ჩავწვდეთ და ის მესიჯი
 გამოვსახოთ, რომელიც ვალიდატორის ფუნქციაში შევქმენით. `?` გვჭირდება
 ყოველი თვისების წინ, რადგან შესაძლოა ისინი არ არსებობდნენ.
 
diff --git a/src/articles/introduction/creating-component.md b/src/articles/introduction/creating-component.md
index 82c320e..3bd043a 100644
--- a/src/articles/introduction/creating-component.md
+++ b/src/articles/introduction/creating-component.md
@@ -92,7 +92,7 @@ export class ChildComponent {}
 უნდა იყოს. `styleUrl`, შესაბამისად, მიუთითებს სტილების ფაილის მისამართზე.
 
 აღსანიშნავია, რომ `@Component` დეკორატორში `templateUrl`-ის მაგივრად შეგვიძლია გამოვიყენოთ
-`template` და მარკაპი პირტაპირ ამ თვისების მნიშვნელობაში ჩავწეროთ, როგორც სტრინგი:
+`template` და მარკაპი პირდაპირ ამ თვისების მნიშვნელობაში ჩავწეროთ, როგორც სტრინგი:
 
 ```ts
 @Component({
diff --git a/src/articles/introduction/interpolation-data-binding.md b/src/articles/introduction/interpolation-data-binding.md
index 8156de9..6df585a 100644
--- a/src/articles/introduction/interpolation-data-binding.md
+++ b/src/articles/introduction/interpolation-data-binding.md
@@ -24,7 +24,7 @@ export class AppComponent {
 }
 ```
 
-მათი გამოსახვა ამავე კომპონენტის თემფლეითში შეგვიძლია ორმაგი კლაკნილი ფრჩხილებით:
+მათი გამოსახვა ამავე კომპონენტის თემფლეითში შეგვიძლია ორმაგი ფიგურული ფრჩხილებით:
 
 ```html
 <h1>{{ title }}</h1>
diff --git a/src/articles/pipes/built-in-pipes.md b/src/articles/pipes/built-in-pipes.md
index c1843e6..ce1750b 100644
--- a/src/articles/pipes/built-in-pipes.md
+++ b/src/articles/pipes/built-in-pipes.md
@@ -6,7 +6,7 @@ title: "ჩაშენებული ფაიფები"
 
 გავეცნოთ ანგულარში ჩაშენებულ ძირითად და ყველაზე გამოყენებად ფაიფებს.
 წინამდებარე ფაიფები `CommonModule`-ის ნაწილია, ამიტომ ის დააიმპორტეთ
-თქვენ კომპონენტში.
+თქვენს კომპონენტში.
 
 ## DatePipe
 
@@ -30,8 +30,8 @@ holiday = new Date(1918, 5, 26);
 დაფორმატებული თარიღი უნდა დავინახოთ.
 
 რადგან ფაიფებს ერთგვარ ფუნქციებად განვიხილავთ, მათთვის პარამეტრების
-მიწოდებაც არის შესაშლებელი ფაიფის სახელის შემდეგ `:` სიმბოლოს საშუალებით,
-რომელსაც უნდა მოყვეს პარამეტრად მისაღები ექსფრეშენი:
+მიწოდებაც არის შესაძლებელი ფაიფის სახელის შემდეგ `:` სიმბოლოს საშუალებით,
+რომელსაც პარამეტრად უნდა მოჰყვეს მისაღები ექსფრეშენი:
 
 ```html
 <p>Georgian independence day is {{ holiday | date:"dd/MM/yy" }}</p>
@@ -87,7 +87,7 @@ budget = 50.335;
 <!-- output 'EUR50.34' -->
 ```
 
-მესამე მაგალითში ჩვენ მეორე პარამეტრს ვაწვდით ფაიფს, რომ ვალუტა
+მესამე მაგალითში ჩვენ ფაიფს მეორე პარამეტრსაც ვაწვდით , რათა ვალუტა
 კოდური სახელით გამოსახოს. როგორც ხედავთ, შესაძლებელია ერთზე
 მეტი პარამეტრის მიწოდება.
 
@@ -95,7 +95,7 @@ budget = 50.335;
 
 `DecimalPipe` გამოიყენება რიცხვების დასაფორმატებლად.
 
-დიდ რიცხვებს ის წაკითხვადი ფორმით აფირმატებს:
+ის დიდ რიცხვებს წაკითხვადი ფორმით აფირმატებს:
 
 ```html
 <p>{{1000000 | number}}</p>
diff --git a/src/articles/pipes/creating-pipe.md b/src/articles/pipes/creating-pipe.md
index f2fe91e..54c6ea8 100644
--- a/src/articles/pipes/creating-pipe.md
+++ b/src/articles/pipes/creating-pipe.md
@@ -6,7 +6,7 @@ title: "ფაიფის შექმნა"
 
 ამ თავში ვისწავლით ფაიფების შექმნას.
 
-წინასწარ გამზადებული გვაქვს სტრინგების მასივი და საფილტრო სიტყვა, რომლის
+წინასწარ გამზადებული გვაქვს სტრინგების მასივი და სიტყვა, რომლის
 მიხედვითაც გვინდა ამ მასივის გაფილტვრა:
 
 ```ts
@@ -55,13 +55,13 @@ ng generate pipe my-filter
 ```
 
 ანგულარი შექმნის ფაილს, რომელიც შეიცავს ჩვენი ფაიფის სახელს + `.pipe.ts`.
-ამ ფაილში დაექსpორტებულია ჩვენი ფაიფის კლასი, რომელიც `Pipe` დეკორატორით
+ამ ფაილში დაექსპორტებულია ჩვენი ფაიფის კლასი, რომელიც `Pipe` დეკორატორით
 არის შექმნილი. ამ დეკორატორში შეგვიძლია ფაიფის კონფიგურაცია, მათ შორის იმ
 სახელის, რომლითაც ამ ფაიფს თემფლეითში გამოვიყენებთ. ჩვენი ფაიფის კლასი
-თავის მხრივ აუცილებლად იმპლემენტაციას უკეთებდეს `PipeTransform` ინტერფეისს.
+თავის მხრივ აუცილებლად იმპლემენტაციას უკეთებს `PipeTransform` ინტერფეისს.
 `PipeTransform` ინტერფეისი საჭიროებს რომ კლასში არსებობდეს `transform` მეთოდი.
 ეს მეთოდი ყველა ფაიფს გააჩნია, თუმცა ყველა მათგანი თავისებურად მუშაობს.
-ჩვენც, რა თქმა უნდა, ის ჩვენ ამოცანას უნდა მოვარგოთ.
+ჩვენც, რა თქმა უნდა, ის ჩვენს ამოცანას უნდა მოვარგოთ.
 
 ```ts
 import { Pipe, PipeTransform } from "@angular/core";
@@ -83,7 +83,7 @@ export class MyFilterPipe implements PipeTransform {
 უნდა გავფილტროთ, ხოლო მეორე პარამეტრიდან იწყება ის არგუმენტები, რომლელსაც
 ჩვენ ფაიფის გამოყენებისას მივაწვდით. ჩვენ გვინდა, რომ გავფილტროთ სტგრინგების მასივი
 რაღაც სიტყვის მიხედვით და ამიტომ ჩვენ დავაბრუნებთ გაფილტრული სტრინგების მასივს,
-სადაც თითოეული ელემენტი (ლოუერქეისში) შეიცავს საფილტრო სიტყვას (ლოუერქეისში).
+სადაც თითოეული ელემენტი (ქვედა რეგისტრში) შეიცავს საფილტრო სიტყვას (ქვედა რეგისტრში).
 
 დარწმუნდით, რომ ჩვენი ფაიფი დამატებულია შესაბამისი კომპონენტის იმპორტების სიაში,
 რათა მისი გამოყენება შევძლოთ:
@@ -114,8 +114,8 @@ export class AppComponent {
 ჩვენი ფილტრის filter ფუნქციაში value არგუმენტი გამოდის items მასივი,
 ხოლო filterKey პარამეტრი გამოდის ჩვენს კომპონენტში არსებული filterKey,
 რომელსაც ngModel-ის საშუალებით მომხმარებლის მიერ შეყვანილი მნიშვნელობა ეძლევა
-და ანგულარ `items`-ს ტრანსფორმაციას უკეთებს და აბრუნებს მასივს მხოლოდ იმ
-ელემენტებიც, რომლებიც ველში შეყვანილ სიტყვას შეიცავენ.
+და ანგულარ `items`-ს ტრანსფორმაციას უკეთებს და აბრუნებს მასივის მხოლოდ იმ
+ელემენტებს, რომლებიც ველში შეყვანილ სიტყვას შეიცავენ.
 
 ## შეჯამება