jaymicrocode
diff --git a/‎00_intro.md‎
Lines changed: 30 additions & 33 deletions b/‎00_intro.md‎
Lines changed: 30 additions & 33 deletions
diff --git a/‎01_values.md‎
Lines changed: 3 additions & 3 deletions b/‎01_values.md‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎02_program_structure.md‎
Lines changed: 10 additions & 10 deletions b/‎02_program_structure.md‎
Lines changed: 10 additions & 10 deletions
diff --git a/‎03_functions.md‎
Lines changed: 7 additions & 8 deletions b/‎03_functions.md‎
Lines changed: 7 additions & 8 deletions
diff --git a/‎04_data.md‎
Lines changed: 11 additions & 12 deletions b/‎04_data.md‎
Lines changed: 11 additions & 12 deletions
diff --git a/‎05_higher_order.md‎
Lines changed: 3 additions & 3 deletions b/‎05_higher_order.md‎
Lines changed: 3 additions & 3 deletions
@@ -298,12 +298,12 @@ console.log(sum(range(1, 10)));
 
 {{index readability}}
 
-The moral of this story is that the same program can
-be expressed in long and short, unreadable and readable ways. The
-first version of the program was extremely obscure, whereas this last
-one is almost English: `log` the `sum` of the `range` of numbers from
-1 to 10. (We will see in [later chapters](04_data.html#data) how to
-build operations like `sum` and `range`.)
+The moral of this story is that the same program can be expressed in
+long and short, unreadable and readable ways. The first version of the
+program was extremely obscure, whereas this last one is almost
+English: `log` the `sum` of the `range` of numbers from 1 to 10. (We
+will see in [later chapters](data) how to build operations like `sum`
+and `range`.)
 
 {{index ["programming language", "power of"], composability}}
 
@@ -372,7 +372,7 @@ them out to you.
 This flexibility also
 has its advantages, though. It leaves space for a lot of techniques
 that are impossible in more rigid languages, and as you will see (for
-example in [Chapter 10](10_modules.html#modules)) it
+example in [Chapter ?](modules#modules)) it
 can be used to overcome some of JavaScript's shortcomings. After
 ((learning)) the language properly and working with it for a while, I have
 learned to actually _like_ JavaScript.
@@ -399,7 +399,7 @@ Web browsers are not the only platforms on
 which JavaScript is used. Some databases, such as MongoDB and CouchDB,
 use JavaScript as their scripting and query language. Several
 platforms for desktop and server programming, most notably the
-((Node.js)) project (the subject of [Chapter 20](20_node.html#node)) are providing a powerful environment for programming JavaScript
+((Node.js)) project (the subject of [Chapter ?](node)) are providing a powerful environment for programming JavaScript
 outside of the browser.
 
 ## Code, and what to do with it
@@ -468,50 +468,47 @@ JavaScript in.
 
 Throughout the book, there are five _project chapters_, which describe
 larger example programs to give you a taste of real programming. In
-order of appearance, we will work through building an
-[artificial life simulation](07_elife.html#elife), a
-[programming language](11_language.html#language), a
-[platform game](15_game.html#game), a
-[paint program](19_paint.html#paint), and a
-[dynamic website](21_skillsharing.html#skillsharing).
+order of appearance, we will work through building a [robot](robot), a
+[programming language](language), a [platform game](game), a [paint
+program](paint), and a [dynamic website](skillsharing).
 
 The language part of the book starts with four chapters to introduce
 the basic structure of the JavaScript language. They introduce
-[control structures](02_program_structure.html#program_structure)
+[control structures](program_structure)
 (such as the `while` word you saw in this introduction),
-[functions](03_functions.html#functions) (writing your own
-operations), and [data structures](04_data.html#data). After these,
+[functions](functions) (writing your own
+operations), and [data structures](data). After these,
 you will be able to write simple programs. Next, Chapters
-[5](05_higher_order.html#higher_order) and
-[6](06_object.html#object) introduce techniques to use functions
+[5](higher_order) and
+[6](object) introduce techniques to use functions
 and objects to write more _abstract_ code and thus keep complexity
 under control.
 
-After a [first project chapter](07_elife.html#elife), the first
+After a [first project chapter](robot), the first
 part of the book continues with chapters on
-[error handling and fixing](08_error.html#error), on
-[regular expressions](09_regexp.html#regexp) (an important tool for
+[error handling and fixing](error), on
+[regular expressions](regexp) (an important tool for
 working with text data), and on
-[modularity](10_modules.html#modules)—another weapon against
-complexity. The [second project chapter](11_language.html#language)
+[modularity](modules)—another weapon against
+complexity. The [second project chapter](language)
 concludes the first part of the book.
 
-The second part, Chapters [12](12_browser.html#browser) to
-[19](19_paint.html#paint), describes the tools that browser
+The second part, Chapters [?](browser) to
+[?](paint), describes the tools that browser
 JavaScript has access to. You'll learn to display things on the screen
-(Chapters [13](13_dom.html#dom) and
-[16](16_canvas.html#canvas)), respond to user input (Chapters
-[14](14_event.html#event) and [18](18_forms.html#forms)), and
-communicate over the network ([Chapter 17](17_http.html#http)).
+(Chapters [?](dom) and
+[?](canvas)), respond to user input (Chapters
+[?](event) and [?](forms)), and
+communicate over the network ([Chapter ?](http)).
 There are again two project chapters in this part.
 
-After that, [Chapter 20](20_node.html#node) describes Node.js, and
-[Chapter 21](21_skillsharing.html#skillsharing) builds a simple web
+After that, [Chapter ?](node) describes Node.js, and
+[Chapter ?](skillsharing) builds a simple web
 system using that tool.
 
 {{if commercial
 
-Finally, [Chapter 22](22_fast.html#fast) describes some of the
+Finally, [Chapter ?](fast) describes some of the
 considerations that come up when optimizing JavaScript programs for
 speed.
 
 
@@ -319,7 +319,7 @@ produce the string `"concatenate"`:
 ```
 
 Strings also have a number of associated functions (_methods_) which
-we will come back to in [Chapter 4](04_data.html#methods).
+we will come back to in [Chapter ?](data#methods).
 
 {{{index interpolation, backtick}}}
 
@@ -358,7 +358,7 @@ console.log(typeof "x")
 
 We will use `console.log` in example code to indicate that we want to
 see the result of evaluating something. More about that in the [next
-chapter](02_program_structure.html).
+chapter](program_structure).
 
 {{index negation, "- operator", "binary operator", "unary operator"}}
 
@@ -677,5 +677,5 @@ logically, and `typeof` to find a value's type) and a ternary operator
 
 This gives you enough information to use JavaScript as a pocket
 calculator, but not much more. The [next
-chapter](02_program_structure.html#program_structure) will start tying
+chapter](program_structure) will start tying
 these expressions together into basic programs.
@@ -22,7 +22,7 @@ the point where we can express meaningful prose.
 
 {{index grammar, syntax, [code, "structure of"], grammar, [JavaScript, syntax]}}
 
-In [Chapter 1](01_values.html#values), we made some values and applied
+In [Chapter ?](values), we made some values and applied
 operators to them to get new values. Creating values like this is the
 main substance of any JavaScript program. But that substance has to be
 framed in a larger structure to be useful. So that's what we'll get to
@@ -186,7 +186,7 @@ console.log(greeting + name);
 
 The first, `var` (short for "variable"), is the way bindings were
 declared in pre-2015 JavaScript. We'll get back to the precise way it
-differs from `let` in the [next chapter](03_functions.html). For now,
+differs from `let` in the [next chapter](functions). For now,
 remember that it mostly does the same thing, but we'll rarely use it
 in this book because it has some confusing properties.
 
@@ -309,7 +309,7 @@ Though binding names cannot contain ((period character))s,
 simple binding. It is actually an expression that retrieves the `log`
 ((property)) from the value held by the `console` binding. We will
 find out exactly what this means in [Chapter
-4](04_data.html#properties).
+?](data#properties).
 
 {{id return_values}}
 ## Return values
@@ -341,8 +341,8 @@ console.log(Math.min(2, 4) + 100);
 // → 102
 ```
 
-The [next chapter](03_functions.html#functions) explains how to
-write your own functions.
+The [next chapter](functions) explains how to write your own
+functions.
 
 ## Control flow
 
@@ -551,7 +551,7 @@ console.log(result);
 
 The counter could also have started at `1` and checked for `<= 10`,
 but, for reasons that will become apparent in [Chapter
-4](04_data.html#array_indexing), it is a good idea to get used to
+?](data#array_indexing), it is a good idea to get used to
 counting from 0.
 
 {{index "loop body", "do loop", "control flow"}}
@@ -639,7 +639,7 @@ for (let number = 0; number <= 12; number = number + 2) {
 {{index "control flow", state}}
 
 This program is exactly equivalent to the
-[earlier](02_program_structure.html#loops) even-number-printing
+[earlier](program_structure#loops) even-number-printing
 example. The only change is that all the ((statement))s that are
 related to the “state” of the loop are now grouped together.
 
@@ -835,7 +835,7 @@ mixed naming styles can be jarring to read, so we follow this
 In a few cases, such as the `Number` function, the first letter of a
 binding is also capitalized. This was done to mark this function as a
 constructor. What a constructor is will become clear in [Chapter
-6](06_object.html#constructors). For now, the important thing is not
+?](object#constructors). For now, the important thing is not
 to be bothered by this apparent lack of ((consistency)).
 
 ## Comments
@@ -910,7 +910,7 @@ a function call is an expression, and may produce a value.
 {{index exercises}}
 
 If you are unsure how to try your solutions to exercises, refer to the
-[introduction](00_intro.html#intro).
+[introduction](intro).
 
 Each exercise starts with a problem description. Read that and try to
 solve the exercise. If you run into problems, consider reading the
@@ -966,7 +966,7 @@ if}}
 
 You can start with a program that simply prints out the numbers 1 to
 7, which you can derive by making a few modifications to the [even
-number printing example](02_program_structure.html#loops) given
+number printing example](program_structure#loops) given
 earlier in the chapter, where the `for` loop was introduced.
 
 Now consider the equivalence between numbers and strings of hash
 
@@ -250,9 +250,8 @@ if (safeMode) {
 
 {{index [function, "higher-order"]}}
 
-In [Chapter 5](05_higher_order.html#higher_order), we will discuss the
-wonderful things that can be done by passing around function values to
-other functions.
+In [Chapter ?](higher_order), we will discuss the wonderful things
+that can be done by passing around function values to other functions.
 
 ## Declaration notation
 
@@ -344,7 +343,7 @@ const horn = () => {
 Arrow functions are a relatively recent addition to the language, and
 their main use is to allow simple function expressions to be less
 verbose. We'll be using a lot of them in [Chapter
-5](05_higher_order.html).
+?](higher_order).
 
 {{id stack}}
 ## The call stack
@@ -493,7 +492,7 @@ console.log(power(2, 6));
 
 {{index "console.log"}}
 
-In the [next chapter](04_data.html#rest_parameters), we will see a way
+In the [next chapter](data#rest_parameters), we will see a way
 in which a function body can get at the whole list of arguments it was
 passed. This is helpful because it makes it possible for a function to
 accept any number of arguments. For example, `console.log` makes use
@@ -620,7 +619,7 @@ machine-friendliness. Almost any program can be made faster by making
 it bigger and more convoluted. The programmer must decide on an
 appropriate balance.
 
-In the case of the [earlier](03_functions.html#power) `power`
+In the case of the [earlier](functions#power) `power`
 function, the inelegant (looping) version is still fairly simple and
 easy to read. It doesn't make much sense to replace it with the
 recursive version. Often, though, a program deals with such complex
@@ -970,7 +969,7 @@ the way that chapters and sections help organize a text.
 
 {{index "Math object", "minimum (exercise)", "Math.min function", minimum}}
 
-The [previous chapter](02_program_structure.html#return_values)
+The [previous chapter](program_structure#return_values)
 introduced the standard function `Math.min` that returns its smallest
 argument. We can do that ourselves now. Write a function `min` that
 takes two arguments and returns their minimum.
@@ -1046,7 +1045,7 @@ if}}
 
 Your function will likely look somewhat similar to the inner `find`
 function in the recursive `findSolution`
-[example](03_functions.html#recursive_puzzle) in this chapter, with an
+[example](functions#recursive_puzzle) in this chapter, with an
 `if`/`else if`/`else` chain that tests which of the three cases
 applies. The final `else`, corresponding to the third case, makes the
 recursive call. Each of the branches should contain a `return`
 
@@ -208,7 +208,7 @@ uppercase. There is also `toLowerCase`, going the other way.
 Interestingly, even though the call to `toUpperCase` does not pass any
 arguments, the function somehow has access to the string `"Doh"`, the
 value whose property we called. How this works is described in
-[Chapter 6](06_object.html#obj_methods).
+[Chapter ?](object#obj_methods).
 
 Properties that contain functions are generally called _methods_ of
 the value they belong to. As in, “_toUpperCase_ is a method of a
@@ -242,7 +242,7 @@ a _((stack))_. A stack, in programming, is a ((data structure)) that
 allows you to push values into it and pop them out again in the
 opposite order—the thing that was added last is removed first. These
 are common in programming—you might remember the function ((call
-stack)) from [the previous chapter](03_functions.html#stack), which is
+stack)) from [the previous chapter](functions#stack), which is
 an instance of the same idea.
 
 ## Objects
@@ -445,9 +445,8 @@ only if both objects are precisely the same value. Comparing different
 objects will return `false`, even if they have identical contents.
 There is no “deep” comparison operation built into JavaScript, which
 looks at object's contents, but it is possible to write it yourself
-(which will be one of the
-[exercises](04_data.html#exercise_deep_compare) at the end of this
-chapter).
+(which will be one of the [exercises](data#exercise_deep_compare) at
+the end of this chapter).
 
 ## The lycanthrope's log
 
@@ -696,7 +695,7 @@ When a `for` loops looks like this, with the word `of` after a
 variable definition, it will loop over the elements of the value given
 after `of`. This works not only for arrays, but also for strings and
 some other data structures. We'll discuss _how_ it works in [Chapter
-6](06_object.html).
+?](object).
 
 {{id analysis}}
 
@@ -814,7 +813,7 @@ generally useful array methods.
 {{index "push method", "pop method", "shift method", "unshift method"}}
 
 We saw `push` and `pop`, which add and remove elements at the
-end of an array, [earlier](04_data.html#array_methods) in this
+end of an array, [earlier](data#array_methods) in this
 chapter. The corresponding methods for adding and removing things at
 the start of an array are called `unshift` and `shift`.
 
@@ -952,7 +951,7 @@ console.log("  okay \n ".trim());
 We have already seen the string type's `length` property. Accessing
 the individual characters in a string looks like accessing array
 elements (with a caveat that we'll discuss in [Chapter
-5](05_higher_order.html#code_units)).
+?](higher_order#code_units)).
 
 ```
 let string = "abc";
@@ -1075,7 +1074,7 @@ console.log(randomPointOnCircle(2));
 
 If sines and cosines are not something you are very familiar with,
 don't worry. When they are used in this book, in [Chapter
-13](13_dom.html#sin_cos), I'll explain them.
+?](dom#sin_cos), I'll explain them.
 
 {{index "Math.random function", "random number"}}
 
@@ -1268,8 +1267,8 @@ You can iterate over arrays using a special kind of `for` loop—`for
 
 {{index "summing (exercise)"}}
 
-The [introduction](00_intro.html) of this book alluded to the
-following as a nice way to compute the sum of a range of numbers:
+The [introduction](intro) of this book alluded to the following as a
+nice way to compute the sum of a range of numbers:
 
 ```{test: no}
 console.log(sum(range(1, 10)));
@@ -1359,7 +1358,7 @@ Neither may use the standard `reverse` method.
 {{index efficiency, "pure function", "side effect"}}
 
 Thinking back to the notes about side effects and pure functions in
-the [previous chapter](03_functions.html#pure), which variant do you
+the [previous chapter](functions#pure), which variant do you
 expect to be useful in more situations? Which one is more efficient?
 
 {{if interactive
 
@@ -281,7 +281,7 @@ order to process data, we'll need some data. This chapter will use a
 ((data set)) about ((writing system))s—such as Latin, Cyrillic, and
 Arabic.
 
-Remember ((Unicode)) from [Chapter 1](01_values.html#unicode), the
+Remember ((Unicode)) from [Chapter ?](values#unicode), the
 system that assigns a number to each character in written language.
 Most of these characters are associated with a script. The standard
 contains 140 different scripts. 81 of those are still in use today.
@@ -609,7 +609,7 @@ the elements in the array.
 
 But how do we get the character codes in a string?
 
-In [Chapter 1](01_values.html) I mentioned that JavaScript ((string))s
+In [Chapter ?](values) I mentioned that JavaScript ((string))s
 are encoded as a sequence of 16-bit number called _((code unit))s_. A
 ((Unicode)) ((character)) code was initially supposed to fit within
 such a unit (which gives you a little over 65 thousand characters).
@@ -662,7 +662,7 @@ charcter takes up one or two code units.
 
 {{index "for/of loop", character}}
 
-In the [previous chapter](04_data.html#for_of_loop), I mentioned that
+In the [previous chapter](data#for_of_loop), I mentioned that
 a `for`/`of` loop can also be used on strings. Like `codePointAt`,
 this type of loop was introduced at a time where people were acutely
 aware of the problems with UTF-16. And when you use it to loop over a