First step in order to redo the generated site

Author: BonsaiDen

doc/arrayctor.md renamed to doc/array/constructor.md

@@ -1,17 +1,17 @@
-## Arrays
+## Array iteration and properties
 
 Although arrays in JavaScript are objects, there are no good reasons to use
-the [for in loop](#forinloop) in for iteration on them. In fact there are a 
-number of good reasons **against** the use of `for in` on arrays.
+the [for in loop](#object.forinloop) in for iteration on them. In fact there are 
+a  number of good reasons **against** the use of `for in` on arrays.
 
 > **Note:** JavaScript arrays are **not** *associative arrays*. JavaScript only 
-> has [objects](#objects) for mapping keys to values. And while associative 
+> has [objects](#object.general) for mapping keys to values. And while associative 
 > arrays **preserve** order, objects do **not**.
 
 Since the `for in` loop enumerates all properties on the prototype chain and 
 the only way to exclude those properties is to use 
-[`hasOwnProperty`](#hasownproperty), it is already up to **twenty times** slower
-than a normal `for` loop.
+[`hasOwnProperty`](#object.hasownproperty), it is already up to **twenty times**
+slower than a normal `for` loop.
 
 ### Iteration
 

doc/arrays.md renamed to doc/array/general.md

@@ -29,9 +29,9 @@ achieved **without** it.
 
 ### `eval` in disguise
 
-The [timeout functions](#timeouts) `setTimeout` and `setInterval` can both take a string as
-their first argument. This string will **always** get executed in the global 
-scope since `eval` is not being called directly in that case.
+The [timeout functions](#other.timeouts) `setTimeout` and `setInterval` can both 
+take a string as their first argument. This string will **always** get executed 
+in the global scope since `eval` is not being called directly in that case.
 
 ### Security issues
 

doc/eval.md renamed to doc/core/eval.md

@@ -31,7 +31,7 @@ necessary to retrieve the value of `undefined` in the first place.
 
 In order to protect code against a possible overwritten `undefined` variable, a 
 common technique used is to add an additional parameter to the encapsulation
-[anonymous wrapper](#scopes), which gets no argument passed to it.
+[anonymous wrapper](#function.scopes), which gets no argument passed to it.
 
     var undefined = 123;
     (function(something, foo, undefined) {

doc/semicolon.md renamed to doc/core/semicolon.md

@@ -3,7 +3,7 @@
 One of JavaScript's most powerful features is the availability of *closures*,
 this means that scopes **always** keep access to the outer scope they were
 defined in. Since the only scope that JavaScript has is the 
-[function scope](#scopes), all functions, by default, act as closures.
+[function scope](#function.scopes), all functions, by default, act as closures.
 
 ### Emulating private variables
 
@@ -67,7 +67,7 @@ the value of `i`.
 ### Avoiding the reference problem
 
 In order to copy the value of the loop its index variable, it is best to use an 
-[anonymous wrapper](#scopes).
+[anonymous wrapper](#function.scopes).
 
     for(var i = 0; i < 10; i++) {
         (function(e) {

doc/undefined.md renamed to doc/core/undefined.md

@@ -4,8 +4,8 @@ Constructors in JavaScript are yet again different from many other languages. An
 function call that is preceded by the `new` keyword acts as a constructor.
 
 Inside the constructor (the called function) the value of `this` refers to a 
-newly created `Object`. The [`prototype`](#prototype) of this **new** object is 
-set to the `prototype` of the function object that was called.
+newly created `Object`. The [`prototype`](#object.prototype) of this **new** 
+object is set to the `prototype` of the function object that was called.
 
 If the function that was called has no explicit `return` statement, then it
 implicitly returns the value of `this` (the new object). Otherwise it returns
@@ -27,8 +27,8 @@ created object to `Foo.prototype`.
 
 Keep in mind that if you do not use the `new` keyword the function will **not**
 return a new object. While it might still work due to the workings of
-[`this`](#how-this-works-in-javascript) in JavaScript, it will use the *global*
-object as the value of `this`.
+[`this`](#function.this) in JavaScript, it will use the *global* object as the 
+value of `this`.
 
 ### Factories
 
@@ -51,7 +51,7 @@ explicitly return a value.
     Bar();
 
 Both these calls return the exact same thing, a newly create object which
-has a property called `method` which is a [Closure](#closures-and-references).
+has a property called `method` which is a [Closure](#function.closures).
 
 Also note that the call `new Bar()` does **not** affect the prototype of the
 returned object. While the prototype will be set on the newly created object,
@@ -85,7 +85,7 @@ object inside it.
     }
 
 While the above is robust against forgetting to use `new` and makes the use of
-[private variables](#closures) certainly easier, it comes with some down sides.
+[private variables](#function.closures) certainly easier, it comes with some down sides.
 
  1. It uses more memory since the created objects do **not** share the methods
  2. In order to inherit the factory needs to copy all the methods from another

doc/arguments.md renamed to doc/function/arguments.md

@@ -1,4 +1,4 @@
-## Functions
+## Function declarations and expressions
 
 Functions in JavaScript are first class objects, which means that they can be 
 passed around like any other value. One common use of this feature is to pass
@@ -30,7 +30,7 @@ declaration - creates the variable `foo` before the actual execution of the code
 starts, `foo` is already defined when the script gets executed.
 
 Since assignments only happens at runtime, the value of `Foo` will default
-to [undefined](#undefined) before the corresponding code is executed.
+to [undefined](#core.undefined) before the corresponding code is executed.
 
 ### Named function expression
 
@@ -43,7 +43,7 @@ Another special case is the assignment of named functions.
 
 Here `bar` is not available in the outer scope, since the function only gets
 assigned to `foo`; however, inside of `bar` it **is** available. This is due to 
-how [name resolution](#scopes) in JavaScript works, the name of the function
+how [name resolution](#function.scopes) in JavaScript works, the name of the function
 is always made available in the local scope of the function itself.
 
 ### The `var` statement
@@ -62,8 +62,8 @@ is always made available in the local scope of the function itself.
         var foo = 1;
     }
 
-Since there is **no** [block scope](#scopes) in JavaScript, the above will
-**not** assign the value `2` to the *global* variable `bar`. It will rather 
+Since there is **no** [block scope](#function.scopes) in JavaScript, the above 
+will **not** assign the value `2` to the *global* variable `bar`. It will rather 
 assign the value of `2` to the *local* variable `bar` of `test`. 
 
 Also, while the statements inside the `if` block never get executed, the variable

doc/closures.md renamed to doc/function/closures.md

@@ -14,7 +14,7 @@ is in the language is *function scope*.
 > **Note:** When not used in an assignment, return statement or as a function 
 > argument, the `{...}` notation will get interpreted as a block statement and 
 > **not** as an object literal. This, in conjunction with 
-> [automatic insertion of semicolons](#semicolon), can lead to subtle errors.
+> [automatic insertion of semicolons](#core.semicolon), can lead to subtle errors.
 
 There are also no distinct namespaces in JavaScript. This means that everything 
 gets defined in **one** globally shared namespace.
@@ -72,8 +72,9 @@ unless the desired effect **is** to affect the outer scope.
 
 ### Local variables
 
-The only source for local variables in JavaScript are [function](#functions)
-parameters and variables that were declared via the `var` statement.
+The only source for local variables in JavaScript are
+[function](#function.general) parameters and variables that were declared via the
+`var` statement.
 
     // global scope
     var foo = 1;
@@ -95,9 +96,9 @@ the assignment of `bar` will override the global variable with the same name.
 ### Name resolution order
 
 All scopes in JavaScript - including the global one - have the name 
-[this](#this) defined in them, which refers to the  "current object". 
+[this](#function.this) defined in them, which refers to the  "current object". 
 
-Function scopes also have the name [arguments](#arguments) defined, which 
+Function scopes also have the name [arguments](#function.arguments) defined, which 
 contains the arguments that were passed to a function.
 
 For example, when trying to access a variable named `foo` inside the scope of a 
@@ -127,8 +128,8 @@ easily avoided with the help of anonymous *function wrappers*.
     })(); // execute the function immediately
 
 
-Unnamed functions are considered [expressions](#functions); so in order to being
-callable, they must first be evaluated.
+Unnamed functions are considered [expressions](#function.general); so in order to
+being callable, they must first be evaluated.
 
     ( // evaluate the function inside the paranthesis
     function() {}