chore(examples): add Kotlin/JS examples

Author: AlexanderPrendota

examples/09_kjs/00_description.md

@@ -0,0 +1,2 @@
+# Kotlin/JS
+

examples/09_kjs/01_dynamic.md

@@ -0,0 +1,38 @@
+# dynamic
+
+*dynamic* is a special type in Kotlin/JS. It basically turns off Kotlin's type checker.
+That is needed in order  to interoperate with untyped or loosely typed environments, such 
+as the JavaScript ecosystem.
+
+<div class="language-kotlin" theme="idea" data-min-compiler-version="1.3" data-target-platform="js">
+
+```kotlin
+fun main(){
+//sampleStart
+  val a: dynamic = "abc"                                               // 1
+  val b: String = a                                                    // 2
+  
+  fun firstChar(s: String) = s[0]
+  
+  println("${firstChar(a)} == ${firstChar(b)}")                        // 3
+  
+  println("${a.charCodeAt(0, "dummy argument")} == ${b[0].toInt()}")   // 4
+  
+  println(a.charAt(1).repeat(3))                                       // 5
+  
+  fun plus(v: dynamic) = v + 2
+  
+  println("2 + 2 = ${plus(2)}")                                        // 6
+  println("'2' + 2 = ${plus("2")}")
+//sampleEnd
+}
+```
+
+</div>
+
+1. Any value can be assigned to variable to `dynamic` type
+2. Dynamic value can be assigned to anything.
+3. Dynamic value can be passed as argument to any function
+4. Any property or function with any arguments can be called on `dynamic` value 
+5. Dynamic call always returns dynamic value, so it is possible to chain them.
+6. Operators, assignments and indexed access (`[..]`) are translated "as is". Beware!

examples/09_kjs/02_js_function.md

@@ -0,0 +1,24 @@
+# JS function
+
+You can inline some JavaScript code into your Kotlin code using the `js("…")` function.
+Should be used with extreme care. 
+
+<div class="language-kotlin" theme="idea" data-min-compiler-version="1.3" data-target-platform="js">
+
+```kotlin
+fun main(){
+//sampleStart
+  val json = js("{}")               // 1
+  json.name = "Jane"                // 2
+  json.hobby = "movies"
+  
+  println(JSON.stringify(json))     // 3
+//sampleEnd
+}
+```
+
+</div>
+
+1. Create a JavaScript object literal. The `js(...)` function return type is `dynamic`.
+2. Add some properties by utilizing the `dynamic` type capabilities.
+3. Pass the JSON to JavaScript API.

examples/09_kjs/03_external.md

@@ -0,0 +1,24 @@
+# External declarations
+
+*external* keyword allows to declare existing JavaScript API in a type-safe way.
+
+<div class="language-kotlin" theme="idea" data-min-compiler-version="1.3" data-target-platform="js">
+
+```kotlin
+external fun alert(msg: String)   // 1
+
+fun main() {
+  alert("Hi!")                    // 2
+}
+```
+
+</div>
+
+1. Declare an existing JavaScript function `alert` which takes a single `String` argument
+2. Use it as if it was regular Kotlin.
+
+Note that Kotlin checks during compilation that exactly a single argument of type `String` is passed.
+That prevents a number of bugs even when using pure JavaScript API - same as with regular Kotlin.
+
+Please [refer to the docs](https://kotlinlang.org/docs/reference/js-interop.html#external-modifier) in order 
+to learn more about describing existing JavaScript API.