Merge pull request #302 from louwers/patch-2

Update path.md

Author: SaltyAom

docs/essential/path.md

@@ -7,7 +7,7 @@ head:
 
     - - meta
       - name: 'description'
-        content: Path or pathname is an identifier to locate resources from a server. Elysia uses the path and method to look up the correct resource. Path in Elysia can be categorized into 3 types. Static, Dynamic and Wildcard.
+        content: A path or pathname is an identifier to locate resources of a server. Elysia uses the path and method to look up the correct resource. Paths in Elysia can be categorized into 3 types: Static, Dynamic and Wildcard.
 
     - - meta
       - property: 'og:description'
@@ -48,7 +48,7 @@ const demo4 = new Elysia()
 
 # Path
 
-Path or pathname is an identifier to locate resources from a server.
+A path or pathname is an identifier to locate resources of a server.
 
 ```bash
 http://localhost:/path/page
@@ -76,15 +76,15 @@ We can categorize the URL and path as follows:
 If the path is not specified, the browser and web server will treat the path as '/' as a default value.
 :::
 
-Elysia will lookup each request for [route](/essential/route) and response using [handler](/essential/handler) function.
+Elysia will look up each request for [route](/essential/route) and response using [handler](/essential/handler) function.
 
 ## Dynamic path
 
 URLs can be both static and dynamic.
 
-Static path means a hardcoded string can be used to locate resources from the server while dynamic path matches some part and captures the value to extract extra information.
+Static paths are hardcoded strings that can be used to locate resources of the server, while dynamic paths match some part and captures the value to extract extra information.
 
-For instance, we can extract the user ID from the pathname, we can do something like:
+For instance, we can extract the user ID from the pathname. For example:
 
 ```typescript twoslash
 import { Elysia } from 'elysia'
@@ -95,7 +95,7 @@ new Elysia()
     .listen(3000)
 ```
 
-We create a dynamic path with `/id/:id` which tells Elysia to match any path up until `/id` and after it could be any value, which is then stored as **params** object.
+Here dynamic path is created with `/id/:id` which tells Elysia to match any path up until `/id`. What comes after that is then stored as **params** object.
 
 <Playground
   :elysia="demo1"
@@ -120,21 +120,21 @@ When requested, the server should return the response as follows:
 | /id                    | Not Found |
 | /id/anything/rest      | Not Found |
 
-Dynamic path is great to enforce the URL to contain crucial information like ID which then can be used later.
+Dynamic paths are great to include things like IDs, which then can be used later.
 
 We refer to the named variable path as **path parameter** or **params** for short.
 
 ## Segment
 
-URL segment is each path that is composed into a full path.
+URL segments are each path that is composed into a full path.
 
-Segment is separated by `/`.
+Segments are separated by `/`.
 ![Representation of URL segments](/essential/url-segment.webp)
 
 Path parameters in Elysia are represented by prefixing a segment with ':' followed by a name.
 ![Representation of path parameter](/essential/path-parameter.webp)
 
-Path parameters allow Elysia to capture a specific segment of URL.
+Path parameters allow Elysia to capture a specific segment of a URL.
 
 The named path parameter will then be stored in `Context.params`.
 
@@ -144,9 +144,9 @@ The named path parameter will then be stored in `Context.params`.
 | /id/:id   | /id/hi | id=hi   |
 | /id/:name | /id/hi | name=hi |
 
-## Multiple path parameter
+## Multiple path parameters
 
-You can have as many path parameters as you would like, which will then be stored into a `params`.
+You can have as many path parameters as you like, which will then be stored into a `params` object.
 
 ```typescript twoslash
 import { Elysia } from 'elysia'
@@ -174,7 +174,7 @@ new Elysia()
   }" 
 />
 
-Requesting to the server should return the response as the following:
+The server will respond as follows:
 
 | Path                   | Response      |
 | ---------------------- | ------------- |
@@ -185,13 +185,13 @@ Requesting to the server should return the response as the following:
 | /id                    | Not Found     |
 | /id/anything/rest      | anything rest |
 
-## Wildcard
+## Wildcards
 
-Dynamic path allows us to capture certain segments of the URL.
+Dynamic paths allow capturing certain segments of the URL.
 
-However, when you need a value of the path to be more dynamic and capture the rest of the URL segment, a wildcard can be used.
+However, when you need a value of the path to be more dynamic and want to capture the rest of the URL segment, a wildcard can be used.
 
-Wildcard can capture the value after segment regardless of amount by using "\*".
+Wildcards can capture the value after segment regardless of amount by using "\*".
 
 ```typescript twoslash
 import { Elysia } from 'elysia'
@@ -218,7 +218,7 @@ new Elysia()
   }" 
 />
 
-Sending a request to the server should return the response as the following:
+In this case the server will respons as follows:
 
 | Path                   | Response      |
 | ---------------------- | ------------- |
@@ -229,27 +229,27 @@ Sending a request to the server should return the response as the following:
 | /id                    | Not Found     |
 | /id/anything/rest      | anything/rest |
 
-A wildcard is useful for capturing a path until a specific point.
+Wildcards are useful for capturing a path until a specific point.
 
 ::: tip
 You can use a wildcard with a path parameter.
 :::
 
-## Summarize
+## Summary
 
 To summarize, the path in Elysia can be grouped into 3 types:
 
--   **static path** - static string to locate the resource
--   **dynamic path** - segment can be any value
--   **wildcard** - path until a specific point can be anything
+-   **static paths** - static string to locate the resource
+-   **dynamic paths** - segment can be any value
+-   **wildcards** - path until a specific point can be anything
 
 You can use all of the path types together to compose a behavior for your web server.
 
-The priority of the path is aligned as follows:
+The priorities are as follows:
 
-1. static path
-2. dynamic path
-3. wildcard
+1. static paths
+2. dynamic paths
+3. wildcards
 
 If the path is resolved as the static wild dynamic path is presented, Elysia will resolve the static path rather than the dynamic path
 
@@ -276,7 +276,7 @@ new Elysia()
   }" 
 />
 
-Sending a request to the server should return the response as the following:
+Here the server will respond as follows:
 
 | Path    | Response      |
 | ------- | ------------- |