MaxCodeXTC
diff --git a/‎00_intro.txt‎
Lines changed: 9 additions & 8 deletions b/‎00_intro.txt‎
Lines changed: 9 additions & 8 deletions
diff --git a/‎01_values.txt‎
Lines changed: 5 additions & 3 deletions b/‎01_values.txt‎
Lines changed: 5 additions & 3 deletions
diff --git a/‎02_program_structure.txt‎
Lines changed: 21 additions & 15 deletions b/‎02_program_structure.txt‎
Lines changed: 21 additions & 15 deletions
diff --git a/‎03_functions.txt‎
Lines changed: 24 additions & 17 deletions b/‎03_functions.txt‎
Lines changed: 24 additions & 17 deletions
@@ -268,9 +268,9 @@ console.log(sum(range(1, 10)));
 The moral of this story, then, 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, while this last one is
-almost English: `log` the `sum` of the `range` of numbers from 1
-to 10. (We will see in later chapters how to build things like `sum`
-and `range`.)
+almost English: `log` the `sum` of the `range` of numbers from 1 to
+10. (We will see in link:04_data.html#data[later chapters] how to
+build things like `sum` and `range`.)
 
 (((programming language,power of)))A good programming language helps
 the programmer by allowing them to talk about the actions that the
@@ -345,7 +345,7 @@ to press)
 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, are providing a
+_((Node.js))_ project, the subject of link:20_node.html#node[Chapter 20], are providing a
 powerful environment for programming JavaScript outside of the
 browser.
 
@@ -375,9 +375,10 @@ endif::html_target[]
 ifdef::tex_target[]
 
 Most of the example code in this book can be found on the book's
-website, at `eloquentjavascript.net/code`, which also provides
-an easy way to run the programs and experiment with writing your own
-code.
+website, at
+http://eloquentjavascript.net/code[_eloquentjavascript.net/code_],
+which also provides an easy way to run the programs and experiment
+with writing your own code.
 
 endif::tex_target[]
 
@@ -386,7 +387,7 @@ book's sandbox is also possible. You can opt to install Node.js, and
 read enough of its documentation to figure out how to use it to
 evaluate text files that contain programs. Or you can use your
 browser's developer console (typically found somewhere under a “tools”
-or “developer” menu) and play around in there. In Chapter 12, the
+or “developer” menu) and play around in there. In link:12_browser.html#script_tag[Chapter 12], the
 way in which JavaScript programs are embedded in web pages (HTML
 files) is explained. In the meantime, you could head over to
 _http://jsbin.com_ for another friendly interface for running
 
@@ -2,6 +2,7 @@
 :prev_link: 00_intro
 :next_link: 02_program_structure
 
+[[values]]
 = Values, Types, and Operators =
 
 [quote, Master Yuan-Ma, The Book of Programming]
@@ -268,7 +269,7 @@ The following line will produce the string `"concatenate"`:
 ----
 
 There are more ways of manipulating strings, which we will discuss
-when we get to methods in Chapter 4.
+when we get to methods in link:04_data.html#methods[Chapter 4].
 
 == Unary operators ==
 
@@ -285,6 +286,7 @@ console.log(typeof "x")
 // → string
 ----
 
+[[console.log]]
 We will use `console.log` in example code to indicate that we want to
 see the result of evaluating something. When you run such code, the
 value produced should be shown on the screen, though how it appears will
@@ -446,7 +448,7 @@ value. They are themselves values, but they carry no
 information.
 
 Many operations in the language that don't produce a meaningful value
-(you'll see some in the next chapter) will yield `undefined` simply
+(you'll see some link:01_values.html#console.log[later]) will yield `undefined` simply
 because they have to yield _some_ value.
 
 The difference in meaning between `undefined` and `null` is an accident
@@ -584,5 +586,5 @@ as several unary operators (`-` to negate a number, `!` to negate
 logically, and `typeof` to find a value's type).
 
 This gives you enough information to use JavaScript as a pocket
-calculator, but not much more. The next chapter will start tying these
+calculator, but not much more. The link:02_program_structure.html#program_structure[next chapter] will start tying these
 basic expressions together into basic programs.
@@ -2,6 +2,7 @@
 :prev_link: 01_values
 :next_link: 03_functions
 
+[[program_structure]]
 = Program Structure =
 
 [chapterquote="true"]
@@ -20,7 +21,7 @@ to the point where we can actually express some meaningful prose.
 
 == Expressions and statements ==
 
-(((grammar)))(((JavaScript,syntax)))In Chapter 1, we made
+(((grammar)))(((JavaScript,syntax)))In link:01_values.html#values[Chapter 1], we made
 some values and then applied operators to them to get new values.
 Creating values like this is an essential part of every JavaScript
 program, but it is still only a part. 
@@ -262,8 +263,9 @@ Though variable names cannot contain dots,
 `console.log` clearly has one. This is because `console.log` isn't 
 a simple variable. It is actually an expression that
 retrieves the `log` field from the value held by the `console`
-variable. We will find out exactly what this means in Chapter 4.
+variable. We will find out exactly what this means in link:04_data.html#properties[Chapter 4].
 
+[[return_values]]
 == Return values ==
 
 (((side effect)))(((return value)))(((max function)))Showing a dialog
@@ -292,7 +294,8 @@ console.log(Math.min(2, 4) + 100);
 // → 102
 ----
 
-The next chapter explains how we can write our own functions.
+The link:03_functions.html#functions[next chapter] explains how we can
+write our own functions.
 
 == prompt and confirm ==
 
@@ -429,6 +432,7 @@ The flow chart for this program looks something like this:
 
 image::img/controlflow-nested-if.svg[alt="Nested if control flow",width="4cm"]
 
+[[loops]]
 == while and do loops ==
 
 (((looping)))Consider a program that prints all even numbers from
@@ -575,9 +579,10 @@ for (var number = 0; number <= 12; number = number + 2)
 ----
 
 (((for loop)))(((control flow)))(((state)))This program is exactly
-equivalent to the earlier even-number-printing example. The only
-change is that all the statements that are related to the “state” of
-the loop are now on one line.
+equivalent to the link:02_program_structure.html#loops[earlier]
+even-number-printing example. The only change is that all the
+statements that are related to the “state” of the loop are now on one
+line.
 
 The parentheses after a `for` keyword must contain two
 semicolons. The part before the first semicolon _initializes_ the
@@ -754,7 +759,7 @@ follow this convention.
 (((Number function)))(((constructor)))In a few cases, such as the
 `Number` function, the first letter of a variable is also capitalized.
 This was done to mark this function as a constructor. What a
-constructor is will become clear in Chapter 6. For now, the important
+constructor is will become clear in link:06_object.html#constructors[Chapter 6]. For now, the important
 thing is not to be bothered by this apparent lack of consistency.
 
 == Comments ==
@@ -828,12 +833,13 @@ If you are unsure how to try your solutions to exercises, refer
  to the end of the introduction.
 
 Each exercise starts with a problem description. Read that and try to
-solve the exercise. If you run into problems, consider reading
-the hints after the exercise. Full solutions to the exercises are not
-included in this book, but you can find them online at _http://eloquentjavascript.net/exercises.html_. If
-you want to learn, I recommend looking at these only after
-you've solved the exercise, or at least after you've attacked it long and hard
-enough to have a slight headache.
+solve the exercise. If you run into problems, consider reading the
+hints after the exercise. Full solutions to the exercises are not
+included in this book, but you can find them online at
+http://eloquentjavascript.net/exercises.html[_eloquentjavascript.net/exercises.html_].
+If you want to learn, I recommend looking at these only after you've
+solved the exercise, or at least after you've attacked it long and
+hard enough to have a slight headache.
 
 === Looping a triangle ===
 
@@ -862,8 +868,8 @@ endif::html_target[]
 
 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 given earlier in the chapter, when the
-`for` loop was introduced.
+link:02_program_structure.html#loops[even-number-printing example]
+given earlier in the chapter, when the `for` loop was introduced.
 
 Now consider the equivalence between numbers and strings of hash
 characters. You can go from 1 to 2 by adding 1 (`+= 1`). You can go
 
@@ -2,6 +2,7 @@
 :prev_link: 02_program_structure
 :next_link: 04_data
 
+[[functions]]
 = Functions =
 
 [chapterquote="true"]
@@ -145,6 +146,7 @@ function-local variables as existing only within the function, the
 language makes it possible to read and understand functions as small
 universes, without having to worry about all the code at once.
 
+[[scoping]]
 == Nested scope ==
 
 (((variable,scope)))(((inner function)))(((nested functions)))
@@ -248,7 +250,7 @@ if (safeMode)
   launchMissiles = function(value) {/* do nothing */};
 ----
 
-In Chapter 5, we will discuss the wonderful things that can be done by
+In link:05_higher_order.html#higher_order[Chapter 5], we will discuss the wonderful things that can be done by
 passing around function values to other functions.
 
 == Declaration notation ==
@@ -302,6 +304,7 @@ function example() {
 }
 ----
 
+[[stack]]
 == The call stack ==
 
 indexsee:[stack,call stack]
@@ -397,6 +400,7 @@ one will tell you about it.
 
 indexsee:[optional argument,argument optional]
 
+[[power]]
 (((argument,optional)))The upside is that this behavior can be used
 to have a function take “optional” arguments. For example, the
 following version of `power` can be called either with two arguments
@@ -422,7 +426,7 @@ console.log(power(4, 3));
 // → 64
 ----
 
-In the next chapter, we will see a way in which a function body can
+In the link:04_data.html#arguments_object[next chapter], we will see a way in which a function body can
 get at the exact list of arguments that were passed. This is helpful
 because it makes it possible for a function to accept any number of
 arguments. `console.log` makes use of this—it outputs all of the
@@ -546,12 +550,12 @@ between human-friendliness and machine-friendliness. Almost
 any program can be made faster by making it
 bigger and more convoluted. The programmer may decide on an appropriate balance.
 
-In the case of the earlier `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 concepts that giving up some
-efficiency in order to make the program more straightforward becomes
-an attractive choice.
+In the case of the link:03_functions.html#power[earlier] `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
+concepts that giving up some efficiency in order to make the program
+more straightforward becomes an attractive choice.
 
 The basic rule, which has been repeated by many programmers and with
 which I wholeheartedly agree, is to not worry about efficiency until
@@ -578,6 +582,7 @@ with loops. Most often these are problems that require exploring or
 processing several “branches”, each of which might branch out again
 into more branches.
 
+[[recursive_puzzle]]
 Consider this puzzle: by starting from the number 1 and repeatedly
 either adding 5 or multiplying by 3, an infinite amount of new
 numbers can be produced. How would you write a function that, given a
@@ -788,6 +793,7 @@ sure you're going to need it. It can be tempting to write general
 Resist that urge. You won't get any real work done, and you'll end up
 writing a lot of code that no one will ever use.
 
+[[pure]]
 == Functions and side effects ==
 
 (((side effect)))(((pure function)))(((function,purity)))Functions
@@ -860,9 +866,10 @@ sections help organize regular text.
 
 === Minimum ===
 
-The previous chapter 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.
+The link:02_program_structure.html#return_values[previous chapter]
+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.
 
 ifdef::html_target[]
 
@@ -928,13 +935,13 @@ endif::html_target[]
 
 !!solution!!
 
-Your function will likely look somewhat similar to the inner `find` function in
-the recursive `findSolution` example in this chapter, with an
-`if`/`else if`/`else` chain that tests which of the three cases
+Your function will likely look somewhat similar to the inner `find`
+function in the recursive `findSolution` link:03_functions.html#recursive_puzzle[example] 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` statement or in some other way
-arrange for a specific value to be returned.
+recursive call. Each of the branches should contain a `return`
+statement or in some other way arrange for a specific value to be
+returned.
 
 When given a negative number, the function will recurse again and
 again, passing itself an ever more negative number, thus getting