chore(docs): fixed multiple typos (winglang#4600)

## Checklist

- [x] Title matches [Winglang's style guide](https://www.winglang.io/contributing/start-here/pull_requests#how-are-pull-request-titles-formatted)
- [x] Description explains motivation and solution
- [ ] Tests added (always)
- [x] Docs updated (only required for features)
- [ ] Added `pr/e2e-full` label if this feature requires end-to-end testing

*By submitting this pull request, I confirm that my contribution is made under the terms of the [Wing Cloud Contribution License](https://github.com/winglang/wing/blob/main/CONTRIBUTION_LICENSE.md)*.

Fixed multiple typos of docs folder:

docs/contributing/01-start-here/05-development.md

@@ -157,7 +157,7 @@ pnpm turbo wing:e2e
 ### Test Meta-Comments
 
 In your wing files in `examples/tests/valid`, you can add a specially formatted comment to add additional information for hangar.
-Inside this comment, a yaml block will be read and used for serveral purposes.
+Inside this comment, a yaml block will be read and used for several purposes.
 
 Example:
 

docs/contributing/01-start-here/07-wingsdk.md

@@ -126,7 +126,7 @@ The SDK resources are written using the Constructs Programming Model.
 constructs serves as the low-level foundation of several other infrastructure-as-code frameworks, such as the [AWS CDK](https://github.com/aws/aws-cdk), [cdk8s](https://github.com/cdk8s-team/cdk8s), and [cdktf](https://github.com/hashicorp/terraform-cdk).
 
 Conceptually, constructs are ordinary classes that additionally have a unique **scope** (parent construct) and **id**.
-By adding constructs as children of other constructs, they can form in-memory trees, where each construct is uniquely addressible based on its location within the tree.
+By adding constructs as children of other constructs, they can form in-memory trees, where each construct is uniquely addressable based on its location within the tree.
 
 A construct's **path** is obtained by joining the sequence of construct ids from the tree root to the construct, with the "/" character.
 For example, if a construct with no parent is declared the root with an id "root", and it has a child named "Child1", the child has a path of "root/Child1".

docs/contributing/03-stories/story-04.md

@@ -224,7 +224,7 @@ As such, our focus for this sprint is:
   - The [language spec](https://github.com/monadahq/winglang-spec) - should go under `docs/winglang-spec.md`
   - The [language requirements RFC](https://www.winglang.io/contributing/rfcs/2022-05-28-winglang-reqs) - 
     should go under `rfcs/winglang-reqs.md`
-  - All issues should also be transfered into this repository.
+  - All issues should also be transferred into this repository.
 - Updating the main README file to match this RFC as close as possible.
 - Update CONTRIBUTING.md to provide step-by-step instructions on how to setup a development environment, compile the toolchain, etc.
 - Set up the workflows required for **continuous releases** - every commit to `main` should result in a full 

docs/contributing/03-stories/story-06.md

@@ -18,7 +18,7 @@ She quickly skims through the blog post, enjoys the authentic tone but even more
 
 ![Landing Page](https://user-images.githubusercontent.com/598796/198871499-55929ad0-0961-4e25-898f-9deb3755dc44.png)
 
-The winglang.io webpage is simple & clean (see [Figma](https://www.figma.com/file/coK9c9XmIgPJ4tlj3dHf0q/winglang.io?node-id=9%3A273)). It shows an animation of some code being written line by-line in IDE (with code completion, syntax highlighting, etc). And then, on the right-hand side, a cloud architecture diagram starts to pop up. For example, when `new cloud.Bucket()` is written, suddently an AWS S3 bucket pops in, when `new cloud.Queue()` is written, a queue is added, etc. Connections form between the cloud resources on the diagram as the relevant code is added.... Suddently, the diagram starts change and switches to a Google Cloud architecture, then to an Azure architecture and then it shows the UI of something called "Wing Console" which seems like it is a UI tool for interacting with the app. Wow this is very intrguiging. She understands from this that this simple code can turn into compelte and complex cloud infra.
+The winglang.io webpage is simple & clean (see [Figma](https://www.figma.com/file/coK9c9XmIgPJ4tlj3dHf0q/winglang.io?node-id=9%3A273)). It shows an animation of some code being written line by-line in IDE (with code completion, syntax highlighting, etc). And then, on the right-hand side, a cloud architecture diagram starts to pop up. For example, when `new cloud.Bucket()` is written, suddenly an AWS S3 bucket pops in, when `new cloud.Queue()` is written, a queue is added, etc. Connections form between the cloud resources on the diagram as the relevant code is added.... Suddenly, the diagram starts change and switches to a Google Cloud architecture, then to an Azure architecture and then it shows the UI of something called "Wing Console" which seems like it is a UI tool for interacting with the app. Wow this is very intrguiging. She understands from this that this simple code can turn into complete and complex cloud infra.
 
 It says below "Sign up for early access". She can't wait... Puts her email and clicks "submit". A message pops up saying that she should be expecting an email from us on how you can register, she goes into her inbox and sees she got an email from Elad that welcomes and asks her to fill in a short form so we can learn more about her before giving her access. She clicks the link. Her web browser takes her to a short form that asks her questions about her job (devops/developer/both/other), how she heard about wing, etc, and also her github username. She submits the form and gets a message, “thank you for submitting the form, please expect a github invitation to github.com/winglang/wing repo in your email”, she goes back to her email where an invite email is awaiting her. Wow these guys are quick! She clicks the link, approves the invite and goes to grab coffee.
 

docs/contributing/03-stories/story-13.md

@@ -12,7 +12,7 @@ Also, it includes some non-functional requirements:
 - Least privileged permissions syntax is defined in RFC
 - The code should work on sim, aws
 - VScode should help developers with code completion and hover
-  - Windows support - vscode extention should work on windows
+  - Windows support - vscode extension should work on windows
   - Hover: when you hover over a symbol you get its type information
 - Console should be able to show all resources, and interact with them
 - The wing command can be used in windows

docs/contributing/03-stories/story-15.md

@@ -20,7 +20,7 @@ The following code is an initial implementation of TaskList with api gateway and
 - [x] console requirements
 - [x] Optionality ? and ??
 - [x] redis is packaged inside our SDK
-- [x] I wanted to use ioredis as an inflight memebr but there are 2 issues:
+- [x] I wanted to use ioredis as an inflight member but there are 2 issues:
   - [x] Missing inflight init (used lazy getter style method instead) 
   - [x] ioredis is from type any (redis.IRedisClient) 
 
@@ -31,7 +31,7 @@ This section focuses on the develoepr experience
 
 ### Redis on localhost 
 
-There is a range of posibilities here:
+There is a range of possibilities here:
 
 One option is to have a a complete battery included solution that handle installing and running redis instance w/wo docker.<br/>
 Another option is taking the do-it-yourself approach that require the developer to setup the instance listening on a configured port.

docs/contributing/999-rfcs/2022-05-28-winglang-reqs.md

@@ -176,7 +176,7 @@ Hub](https://constructs.dev) is central repository for sharing constructs for
 all CDKs, and we indend for wing resources to be part of this ecosystem.
 
 Resources share the capabilities of classic object-oriented classes (such as
-initializers, methods, properties, inheritence, etc) but they have a very unique
+initializers, methods, properties, inheritance, etc) but they have a very unique
 attribute that makes them suitable for defining desired-state through software -
 they have a **deterministic address** across compilations. In traditional
 object-oriented languages, instances of classes also have addresses, but these
@@ -518,12 +518,12 @@ to implement this application for AWS:
 1. Pass the ARN of the topic into the AWS Lambda function through an environment
    variable.
 2. Add `sns:PublishMessage` permissions to the AWS Lambda execution policy, with
-   the least-privilage permissions for this specific topic.
+   the least-privilege permissions for this specific topic.
 3. Include the client library of `cloud.Topic` with implementation for AWS
    in the AWS Lambda bundle.
 
 Resources cannot be defined within inflight functions, because there is no
-synthesizer and no provisiong engine to deploy those resources.
+synthesizer and no provisioning engine to deploy those resources.
 
 > Reqtag: `w:inflight-no-resource-definitions`
 <span id="w:inflight-no-resource-definitions"/>
@@ -739,7 +739,7 @@ implementation for it when we compile.
 
 The wing compiler supports resolving abstract definitions in multiple ways: via
 the compiler command line, a declarative resolution file or library or via
-addiional code (TODO).
+additional code (TODO).
 
 Sketch:
 

docs/contributing/999-rfcs/2023-04-16-website-resource.md

@@ -81,11 +81,11 @@ This can be achieved using the `cloud.Website.add_json` method.
 
 ### Implementation for aws
 
-The method will upload a json object to the bucket, making it accessible withing the static directory.
+The method will upload a json object to the bucket, making it accessible within the static directory.
 
 ### Implementation for the simulator
 
-A new express GET route will be added, returning a Json object containing the dynamic data. The route will be accessible withing the static directory.
+A new express GET route will be added, returning a Json object containing the dynamic data. The route will be accessible within the static directory.
 
 ### point for thought:
 

docs/contributing/999-rfcs/2023-06-12-language-spec.md

@@ -176,7 +176,7 @@ inflight (arg1: <type1>, arg2: <type2>, ...) => <type>
 
 Wing has a data type called `Json` (alias is `json`). This type represents an immutable untyped [JSON
 value](https://www.json.org/json-en.html), including JSON primitives (`string`, `number`,
-`boolean`), arrays (both heterogenous and homogenous) and objects (key-value maps where keys are
+`boolean`), arrays (both heterogenous and homogeneous) and objects (key-value maps where keys are
 strings and values can be any other JSON value)).
 
 `Json` objects are immutable and can be referenced across inflight context.
@@ -1870,7 +1870,7 @@ class Foo {
 ```
 
 Preflight objects all have a scope and a unique ID. Compiler provides an implicit scope
-and ID for each object, both overrideable by user-defined ones in constructor.
+and ID for each object, both overridable by user-defined ones in constructor.
 
 The default for scope is `this`, which means the scope in which the object was
 defined (instantiated). The implicit ID is the type name of the class iff the type

docs/docs/03-language-reference.md

@@ -148,7 +148,7 @@ Return type is optional for closures.
 
 Wing has a primitive data type called `Json`. This type represents an immutable untyped [JSON
 value](https://www.json.org/json-en.html), including JSON primitives (`string`, `number`,
-`boolean`), arrays (both heterogenous and homogenous) and objects (key-value maps where keys are
+`boolean`), arrays (both heterogenous and homogeneous) and objects (key-value maps where keys are
 strings and values can be any other JSON value).
 
 `Json` objects are immutable and can be referenced across inflight context.
@@ -711,7 +711,7 @@ interface FooInterface {
 }
 
 class Foo impl FooInterface {
-  pub public_method() {} // This can be accessed from outside of the class implemenetation
+  pub public_method() {} // This can be accessed from outside of the class implementation
   pub interface_method() {} // This must be explicitly defined as `pub` since it's an interface implementation
 }
 let f = new Foo();
@@ -722,15 +722,15 @@ Access modifier rules apply for both fields and methods of a class.
 Struct fields are always public and do not have access modifiers.
 
 #### 1.5.1 Method overriding and access modifiers
-Private methods cannot be overriden. 
+Private methods cannot be overridden. 
 Overriding a method of a parent class requires the parent class's method to be either `pub` or `protected`.
 The overriding method can have either the same access modifier as the original method or a more permissive one.
-You cannot "decrease" the access level down the inheritence hierarchy, only "increase" it. 
+You cannot "decrease" the access level down the inheritance hierarchy, only "increase" it. 
 In practice this means:
-* `protected` methods can be overidden by either a `protected` or a `pub` method.
-* `pub` methods can be overriden by a `pub` method.
+* `protected` methods can be overridden by either a `protected` or a `pub` method.
+* `pub` methods can be overridden by a `pub` method.
 
-Note that method overriding only applies to instance methods. `static` methods are not treated as part of the inheritence hierarcy.
+Note that method overriding only applies to instance methods. `static` methods are not treated as part of the inheritance hierarchy.
 
 [`▲ top`][top]
 

docs/docs/04-standard-library/01-cloud/service.md

@@ -446,7 +446,7 @@ handle(): IServiceStopHandler
 Handler to run when the service starts.
 
 This is where you implement the initialization logic of
-the service, start any activities asychronously.
+the service, start any activities asynchronously.
 
 DO NOT BLOCK! This handler should return as quickly as possible. If you need to run a long
 running process, start it asynchronously.

docs/docs/04-standard-library/03-std/api-reference.md

@@ -1205,7 +1205,7 @@ Mutable Array.
 | <code><a href="#@winglang/sdk.std.MutArray.pop">pop</a></code> | Remove value from end of array. |
 | <code><a href="#@winglang/sdk.std.MutArray.popAt">popAt</a></code> | Removes value from the given index of an array. |
 | <code><a href="#@winglang/sdk.std.MutArray.push">push</a></code> | Add value to end of array. |
-| <code><a href="#@winglang/sdk.std.MutArray.removeFirst">removeFirst</a></code> | Removes first occurence of a given value in an array. |
+| <code><a href="#@winglang/sdk.std.MutArray.removeFirst">removeFirst</a></code> | Removes first occurrence of a given value in an array. |
 | <code><a href="#@winglang/sdk.std.MutArray.set">set</a></code> | Sets a new value at the given index of an array. |
 
 ---
@@ -1385,7 +1385,7 @@ value to add.
 removeFirst(value: <T>): bool
 ```
 
-Removes first occurence of a given value in an array.
+Removes first occurrence of a given value in an array.
 
 ###### `value`<sup>Required</sup> <a name="value" id="@winglang/sdk.std.MutArray.removeFirst.parameter.value"></a>
 

docs/docs/07-examples/04-flow-controls.md

@@ -10,7 +10,7 @@ keywords: [Wing example]
 let iterable = ["a", "b", "c", "d", "e", "f", "g", "h"];
 for value in iterable {
   if value == "g" {
-    // stoping at g
+    // stopping at g
     break;
   }
   if value == "b" {

libs/wingsdk/src/cloud/service.ts

@@ -178,7 +178,7 @@ export interface IServiceHandler extends IResource {}
 export interface IServiceHandlerClient {
   /**
    * Handler to run when the service starts. This is where you implement the initialization logic of
-   * the service, start any activities asychronously.
+   * the service, start any activities asynchronously.
    *
    * DO NOT BLOCK! This handler should return as quickly as possible. If you need to run a long
    * running process, start it asynchronously.

libs/wingsdk/src/std/array.ts

@@ -295,7 +295,7 @@ export class MutArray {
   }
 
   /**
-   * Removes first occurence of a given value in an array
+   * Removes first occurrence of a given value in an array
    *
    * @macro ((obj, args) => { if (obj.indexOf(args[0]) !== -1) { obj.splice(obj.indexOf(args[0]), 1); return true; } return false; })($self$, [$args$])
    *