diff --git a/docs/.DS_Store b/docs/.DS_Store
index 9120487..0afce74 100644
Binary files a/docs/.DS_Store and b/docs/.DS_Store differ
diff --git a/docs/js/.DS_Store b/docs/js/.DS_Store
new file mode 100644
index 0000000..5d53470
Binary files /dev/null and b/docs/js/.DS_Store differ
diff --git a/docs/js/basics.md b/docs/js/basics.md
deleted file mode 100644
index c3155c4..0000000
--- a/docs/js/basics.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Basics
-
-
-
-## JS on web
-
-```html linenums="1" hl_lines="7-9"
-
-
-
-
-
Lorem ipsum
-
-
-
-
-
-```
-
-JS can be included anywhere in inside an HTML document. The `script` tag can be used without any attributes. When linking external scripts, use `src="/path/to/foo/bar.js"` attribute.
-
-```html
-
-```
-
-when `src` is set, script's inline content is not executed.
-
-## Semicolon
-
-
-
-```javascript
-alert('hi')
-alert('world')
-```
-
-```javascript
-console.log(3 +
-1
-+ 2
-); // logs 6
-```
-
-newline implies a semicolon.
-
-JS doesn't insert a semicolon as the statement is ending on `+`.
-
-
-
-## use strict
-
-```javascript
-"use strict";
-
-// modern JS
-```
-
-directive to enforce modern JS behaviour. However, use of classes and modules automatically enables it.
-
-## Variables
-
-```javascript
-// declaration
-let greeting;
-
-// assignment
-greeting = "hello world";
-
-// combined
-let greeting = "hello world";
-
-// also works for multiple variables.
-let greeting = "hello world", name = "Piggy";
-```
-
-## Constants
-
-```javascript
-const pi = 3; // I'm an engineer. (1)
-
-pi = 3.14; // Uncaught TypeError: Assignment to constant variable.
-```
-
-1. they won't let me near any bridges.
-
-## || and ??
-
-- `||` returns first truthy value.
-- `??` returns first defined value.
-
-```javascript
-null ?? 4 // 4
-null || 4 // 4
-
-0 ?? 4 // 0
-0 || 4 // 4
-```
-
diff --git a/docs/js/hoisting.md b/docs/js/hoisting.md
deleted file mode 100644
index 117f3fc..0000000
--- a/docs/js/hoisting.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# var, hoisting, global
-
-
-
-## Hoisting
-
-The following two snippets are equivalent.
-
-
-
-```javascript linenums="1"
-function foo() {
- name = "oink";
- console.log(name); // 'oink'
- var name;
-}
-```
-
-```javascript linenums="1"
-function foo() {
- var name;
- name = "oink";
- console.log(name); // 'oink'
-}
-```
-
-
-
-Note that only declarations are hoisted, not the accompanying assignments.
-
-```javascript
-function foo() {
- console.log(name); // undefined
- var name = "oink";
-}
-```
-
-JS will hoist even functions, and in fact hoist them before `var`s.
-
-```javascript
-foo(); // 1
-
-function foo() { return 1; }
-var foo = function() { return 2; }
-```
-
-## let vs var
-
-[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)
-
-`let` | `var`
-------|-------
-scoped to blocks | scoped to functions
-can only be accessed after declaration | declarations are hoisted, so can be accessed anytime
-does no create properties in `globalThis` | global `var` and functions become properties of `globalThis`
-cannot be redeclared | redeclarations are ignored and any new value is picked up
-
-## globalThis
-
-Global object is what hosts global variables and functions. In browser it's `window` and in node it's `global`. `globalThis` is a recent standardization.
-
-```javascript
-> globalThis
- Object [global] {
- global: [Circular *1],
- clearImmediate: [Function: clearImmediate],
- setImmediate: [Function: setImmediate] {
- [Symbol(nodejs.util.promisify.custom)]: [Getter]
- },
- clearInterval: [Function: clearInterval],
- clearTimeout: [Function: clearTimeout],
- setInterval: [Function: setInterval],
- setTimeout: [Function: setTimeout] {
- [Symbol(nodejs.util.promisify.custom)]: [Getter]
- },
- queueMicrotask: [Function: queueMicrotask],
- structuredClone: [Function: structuredClone],
- atob: [Getter/Setter],
- btoa: [Getter/Setter],
- performance: [Getter/Setter],
- fetch: [Function: fetch],
- crypto: [Getter],
-}
-```
diff --git a/docs/js/objects.md b/docs/js/objects.md
deleted file mode 100644
index 8fcbe6b..0000000
--- a/docs/js/objects.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Objects
-
-
diff --git a/docs/js/objects/.DS_Store b/docs/js/objects/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/docs/js/objects/.DS_Store differ
diff --git a/docs/js/objects/basics.md b/docs/js/objects/basics.md
new file mode 100644
index 0000000..a348ce9
--- /dev/null
+++ b/docs/js/objects/basics.md
@@ -0,0 +1,126 @@
+# Basics
+
+
+
+An object is an unordered collection of properties, each of which is a key-value pair. The key is usually `string`, but can also be `symbol`. Beyond their own properties, objects can also inherit properties from thier "parent" prototype.
+
+Unlike most other languages, objects in JS are dynamic, so properties can be added and removed at runtime.
+
+## Creating objects
+
+Objects can be created with object literals, `new` keyword and with `Object.create()` call.
+
+## 1. Object literal
+
+```javascript linenums="1"
+// empty object
+let foo = {};
+
+// simple object
+let foo = {
+ age: 42,
+ name: 'bar',
+};
+
+// keys are not valid variable identifier, so use string.
+let name = 'oink oink';
+let foo = {
+ [name]: 'here comes the piggy',
+};
+```
+
+## 2. With new operator
+
+First thing to note that there are no constructors in JS. Instead there is `new` operator. When a function is called with `new` operator, it hijacks the function.
+
+```javascript linenums="1"
+new Object(); // same as {}
+new Array(); // same as []
+```
+
+more on this later.
+
+## 3. Object.create()
+
+
+
+
+
diff --git a/docs/js/objects/prototype.md b/docs/js/objects/prototype.md
new file mode 100644
index 0000000..46c0514
--- /dev/null
+++ b/docs/js/objects/prototype.md
@@ -0,0 +1,107 @@
+# Prototype
+
+
+
+In most languages, object-oriented programming is built through classes and objects. Classes act as blueprints from which objects are created, with classes being a different entity altogether from objects.
+
+In JS, we use delegation through prototypal inheritance.
+
+## [[Prototype]]
+
+All objects in JS have a hidden property called `[[Prototype]]`. This property is a reference to another object. Think of this as the equivalent to superclass of other languages.
+
+```javascript linenums="1"
+{}.__proto__ // [Object: null prototype] {}
+
+Object.getPrototypeOf({}) // [Object: null prototype] {}
+```
+
+Here let's make some distinction between some confusing terms:
+
+`[[Prototype]]` | `__proto__` | `prototype`
+----------------|-------------|--------------
+Internal and hidden property that actually points to another object / `null`. | Historical getter/setter for the actual `[[Prototype]]`.
Use `Object.getPropertyOf` and `Object.setPropertyOf` instead in production code. | e.g. `Object.prototype`, `Array.prototype`, `MyFunction.prototype` etc.
It is **not** `__proto__`, nor is it the `[[Prototype]]` of the function object.
It's same as the value we pass in `Object.create` and is used as the `[[Prototype]]` of created object.
+
+## Examples
+
+
+
+
+Again, to clarify:
+
+- `this` at line is `{ name: 'John' }`, the object we get out of `new Person`.
+- it's a child of `{ age: 42 }`, i.e. `Person.prototype`.
+- which in turn is a child of `Object.prototype`.
+
diff --git a/docs/js/ok.png b/docs/js/ok.png
deleted file mode 100644
index 69b08ac..0000000
Binary files a/docs/js/ok.png and /dev/null differ
diff --git a/docs/js/types.md b/docs/js/types.md
deleted file mode 100644
index ac6ce08..0000000
--- a/docs/js/types.md
+++ /dev/null
@@ -1,223 +0,0 @@
-# Types
-
-
-
-## 1. boolean
-
-Primitive, has only two values `true` or `false`. All values are truthy, except[1](https://developer.mozilla.org/en-US/docs/Glossary/Truthy):
-
-- `false`
-- `0`, `-0`, `0n`
-- `""`
-- `null`, `undefined`
-- `NaN`
-- `document.all` ⚠ deprecated
-
-But since it's Javascript, our exceptions have exceptions. `{}` is truthy, yet `{} == false`. That's because:
-
-```javascript
-String({}) // '[object Object]' non-empty string
-Boolean('[object Object]') // true
-```
-
-## 2. number
-
-JS has no separate `int` and `float` types. Instead all numbers are represented as IEEE 754 64-bit floating numbers. Integers in range \\(\pm2^{53}-1\\) can be represented exactly.
-
-```javascript
-42 // decimal
-0b101010 // in binary (ES6)
-052 // in octal (ES6)
-0o52 // in octal (ES6)
-0x2a // in hexadecimal
-4.2e1 // in exponential
-```
-
-`Number` is the wrapper object around the primitve.
-
-Property | Decription
----------|-------------
-`Number.MAX_VALUE` | Largest representable positive number
-`Number.MAX_SAFE_INTEGER` | Largest safe integer \\(2^{53}-1\\)
-`Number.EPSILON` | Smallest value greater than \\(1\\) that can be represented.
-`Number.NaN` | Special "not a number" value.
-`Number.POSITIVE_INFINITY` | Overflow.
-
-Implicit conversion to numbers generally follow common sense, but don't rely on them. Some conversions to keep in mind:
-
-Value | Converted to| Rationale
-------|-------------|-----------
-`undefined` | `NaN` | unexpected / system-level absence
-`null` | `0` | expected / program-level absence
-`true` | `1` | same as C
-`false` | `0` | same as C
-
-`string`s are trimmed of any whitespaces; empty strings are converted to `0`, and non-empty strings are passed to `Number()` function. Note that `Number(...)` is different from `Number.parseInt(...)`.
-
-