fix typos

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`:

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` ფროფერთიზე სხვა ტიპის მნიშვნელობას მივაბამთ, ეს გამოიწვევს
@@ -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` ჰუკით.

src/articles/data-binding/property-and-attribute-binding.md

@@ -51,9 +51,9 @@ export class AppComponent {
 }
 ```
 
-თი გვსურს რომ `imgData` ობიექტში არსებული `src` და `alt` თვისებათა მნიშვნელობები
+თუ გვსურს რომ `imgData` ობიექტში არსებული `src` და `alt` თვისებათა მნიშვნელობები
 მივაბათ თემფლეითში არსებულ `img` ელემენტს, მაშინ ელემენტზე არსებულ ატრიბუტს ვაქცევთ
-ოთკუთხედ ფრჩხილებში და ტოლობის შემდეგ ვწერთ იმ ცვლადებს, რომლებიც კლასსში არსებობს.
+კვადრატულ ფრჩხილებში და ტოლობის შემდეგ ვწერთ იმ ცვლადებს, რომლებიც კლასში არსებობს.
 ახლა რაღაც თვალსაზრისით, ბრჭყალებში ტაიპსკრიპტის/ჯავასკრიპტის ექსფრეშენები (expressions) მუშაობს.
 
 ```html
@@ -97,8 +97,8 @@ HTML-ში ერთი შეხედვით ელემენტის 
 და იგივე მნიშვნელობები არ ჰქონდეთ.
 
 უშუალოდ HTML-ის ელემენტების ატრიბუტის მოდიფიკაციისთვის, ისევე როგორც ფროფერთი ბაინდინგის
-შემთხვევაშია, ატრიბუტის სახელს ოთხკუთხედ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსა
-და წერტილს, ხოლო ტოლობის შემდეგ ბრჭყალებში უნდა დაიწეროს ქსფრეშენი, რომელის სტრინგწს აბრუნებს:
+შემთხვევაშია, ატრიბუტის სახელს კვადრატულ ფრჩხილებში ვწერთ, თუმცა წინ ვუწერთ `attr` პრეფიქსსა
+და წერტილს, ხოლო ტოლობის შემდეგ ბრჭყალებში უნდა დაიწეროს ექსფრეშენი, რომელის სტრინგს აბრუნებს:
 
 ```html
 <button

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,9 +98,9 @@ fontSizePx = 16;
 <div [style.font-size.px]="fontSizePx">Resizable Text</div>
 ```
 
-რაც ზუსტად იგივეს აკეტებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
-სწორედ ეს არის two way binding. ეს შესაძლებელია მხოლოდ იმ შემთხვევასი, თუ იმ კომპონენტში, რომელზეც
-ჩვენ ბაინდინგს ვაკეტებთ `Input`-ისა და `Output` თვისებების სახელები კონკრეტული კონვენციითაა შექმნილი:
+რაც ზუსტად იმავეს აკეთებს. ჩვენ ერთდროულად ვუსმენთ ცვლილებას და ვაწვდით კონკრეტულ მნიშვნელობას.
+სწორედ ეს არის two way binding. ეს შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ იმ კომპონენტში, რომელზეც
+ჩვენ ბაინდინგს ვაკეთებთ `Input`-ისა და `Output` თვისებების სახელები კონკრეტული კონვენციითაა შექმნილი:
 `Output` თვისება უნდა იწყებოდეს `Input` თვისების დასახელებით და ბოლოში უნდა ემატებოდეს `Change`.
 
 ```ts

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).

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).