Correct inverted uses of "only"

de0u · marijnh · commit d0a740c0816c · 2018-05-02T11:29:53.000+02:00
diff --git a/00_intro.md b/00_intro.md
@@ -357,7 +357,7 @@ underway on an ambitious version 4, which planned a number of radical
 improvements and extensions to the language. Changing a living, widely
 used language in such a radical way turned out to be politically
 difficult, and work on the version 4 was abandoned in 2008, leading to
-a much less ambitious version 5, which only made some uncontroversial
+a much less ambitious version 5, which made only some uncontroversial
 improvements, coming out in 2009. Then in 2015 version 6 came out, a
 major update that included some of the ideas planned for version 4.
 Since then we've had new, small updates every year.
diff --git a/01_values.md b/01_values.md
@@ -256,8 +256,8 @@ match.
 Almost anything can be put between quotes, and JavaScript will make a
 string value out of it. But a few characters are more difficult. You
 can imagine how putting quotes between quotes might be hard.
-_Newlines_ (the characters you get when you press Enter) may only be
-included without escaping when the string is quoted with backticks
+_Newlines_ (the characters you get when you press Enter) may be
+included without escaping only when the string is quoted with backticks
 (`` ` ``).
 
 {{index [escaping, "in strings"], "backslash character"}}
diff --git a/02_program_structure.md b/02_program_structure.md
@@ -135,7 +135,7 @@ console.log(mood);
 
 You should imagine bindings as tentacles, rather than boxes. They do
 not _contain_ values; they _grasp_ them—two bindings can refer to the
-same value. A program can only access the values that it still has a
+same value. A program can access only the values that it still has a
 reference to. When you need to remember something, you grow a tentacle
 to hold on to it or you reattach one of your existing tentacles to it.
 
@@ -411,7 +411,7 @@ doesn't represent a valid number. Thus, the condition translates to
 The statement below the `if` is wrapped in ((curly braces)) (`{` and
 `}`) in this example. Those can be used to group any number of
 statements into a single statement, called a _((block))_. You could
-also have omitted them in this case, since they only hold a single
+also have omitted them in this case, since they hold only a single
 statement, but to avoid having to think about whether they are needed
 or not, most JavaScript programmers use them in every wrapped
 statement like this. We'll mostly follow that convention in this book,
diff --git a/03_functions.md b/03_functions.md
@@ -117,7 +117,7 @@ such bindings wherever you want. These are called _global_.
 {{index "local scope", [binding, local]}}
 
 But bindings created for function ((parameter))s or declared inside a
-function can only be referenced in that function, so they are known as
+function can be referenced only in that function, so they are known as
 _local_ bindings. Every time the function is called, new instances of these
 bindings are created. This provides some isolation between
 functions—each function call acts in its own little world (its local
@@ -151,7 +151,7 @@ console.log(x + z);
 
 Each ((scope)) can "look out" into the scope around it, so `x` is
 visible inside the block in the example. The exception is when
-multiple bindings have the same name—in that case, code can only see
+multiple bindings have the same name—in that case, code can see only
 the innermost one. For example, when the code inside the `halve`
 function refers to `n`, it is seeing its _own_ `n`, not the global
 `n`.
diff --git a/04_data.md b/04_data.md
@@ -166,7 +166,7 @@ the result, converted to a string, as the property name.
 So if you know that the property you are interested in is called
 _color_, you say `value.color`. If you want to extract the property
 named by the value held in the binding `i`, you say `value[i]`.
-Property names are strings. They can be any string, but the dot notation only works with
+Property names are strings. They can be any string, but the dot notation works only with
 names that look like valid binding names. So if you want to access a
 property named _2_ or _John Doe_, you must use square brackets:
 `value[2]` or `value["John Doe"]`.
diff --git a/05_higher_order.md b/05_higher_order.md
@@ -285,7 +285,7 @@ characters are associated with a specific script. The standard
 contains 140 different scripts—81 are still in use today, and 59
 are historic.
 
-Though I can only fluently read Latin characters, I appreciate the
+Though I can fluently read only Latin characters, I appreciate the
 fact that people are writing texts in at least 80 other writing
 systems, many of which I wouldn't even recognize. For example, here's
 a sample of ((Tamil)) handwriting.
diff --git a/06_object.md b/06_object.md
@@ -379,7 +379,7 @@ constructor definition from the previous section. It just looks nicer.
 
 {{index ["class declaration", properties]}}
 
-Class declarations currently only allow _methods_—properties that hold
+Class declarations currently allow only _methods_—properties that hold
 functions—to be added to the ((prototype)). This can be somewhat
 inconvenient when you want to save a non-function value in there.
 The next version of the language will probably improve this. For now, you
@@ -549,7 +549,7 @@ simple interface to use their work.
 {{index "hasOwnProperty method", "in operator"}}
 
 If you do have a plain object that you need to treat as a map for some
-reason, it is useful to know that `Object.keys` only returns an
+reason, it is useful to know that `Object.keys` returns only an
 object's _own_ keys, not those in the prototype. As an alternative to
 the `in` operator, you can use the `hasOwnProperty` method, which
 ignores the object's prototype.
@@ -865,7 +865,7 @@ console.log(temp.celsius);
 
 The `Temperature` class allows you to read and write the temperature
 in either degrees ((Celsius)) or degrees ((Fahrenheit)), but
-internally only stores Celsius, and automatically converts to Celsius
+internally stores only Celsius, and automatically converts to Celsius
 in the `fahrenheit` getter and setter.
 
 {{index "static method"}}
diff --git a/07_robot.md b/07_robot.md
@@ -428,7 +428,7 @@ way we could for 2 + 2. Instead, we have to keep creating potential
 solutions until we find one that works.
 
 The  number of possible routes through a graph is infinite. But
-when searching for a route from _A_ to _B_, we are only interested in
+when searching for a route from _A_ to _B_, we are interested only in
 the ones that start at _A_. We also don't care about routes that visit
 the same place twice—those are definitely not the most efficient route
 anywhere. So that cuts down on the amount of routes that the route
@@ -438,7 +438,7 @@ In fact, we are mostly interested in the _shortest_ route. So we want
 to make sure we look at short routes before we look at longer ones. A
 good approach would be to "grow" routes from the starting point,
 exploring every reachable place that hasn't been visited yet, until a
-route reaches the goal. That way, we'll only explore routes that are
+route reaches the goal. That way, we'll explore only routes that are
 potentially interesting, and find the shortest route (or one of the
 shortest routes, if there are more than one) to the goal.
 
@@ -605,7 +605,7 @@ if}}
 
 {{index "robot efficiency (exercise)"}}
 
-The main limitation of `goalOrientedRobot` is that it only considers
+The main limitation of `goalOrientedRobot` is that it considers only
 one parcel at a time. It will often walk back and forth across the
 village because the parcel it happens to be looking at happens to be
 at the other side of the map, even if there are others much closer.
@@ -646,7 +646,7 @@ value.
 
 {{index singleton}}
 
-Why do you only need one `PGroup.empty` value, rather than having a
+Why do you need only one `PGroup.empty` value, rather than having a
 function that creates a new, empty map every time?
 
 {{if interactive
@@ -693,7 +693,7 @@ To add a property (`empty`) to a constructor that is not a method, you
 have to add it to the constructor after the class definition, as a
 regular property.
 
-You only need one `empty` instance because all empty groups are the
+You need only one `empty` instance because all empty groups are the
 same and instances of the class don't change. You can create many
 different groups from that single empty group without affecting it.
 
diff --git a/08_error.md b/08_error.md
@@ -208,7 +208,7 @@ Computers are good at repetitive tasks, and testing is the ideal
 repetitive task. Automated testing is the process of writing a program
 that tests another program. Writing tests is a bit more work than
 testing manually, but once you've done it you gain a kind of
-superpower: it only takes you a few seconds to verify that your
+superpower: it takes you only a few seconds to verify that your
 program still behaves properly in all the situations you wrote tests
 for. When you break something, you'll immediately notice, rather than
 randomly running into it at some later time.
@@ -362,7 +362,7 @@ have the network fail.
 
 {{index "error recovery"}}
 
-If you're only programming for yourself, you can afford to just ignore
+If you're programming only for yourself, you can afford to just ignore
 such problems until they occur. But if you build something that is
 going to be used by anybody else, you usually want the program to do
 better than just crash. Sometimes the right thing to do is take the
diff --git a/09_regexp.md b/09_regexp.md
@@ -444,7 +444,7 @@ console.log(getDate("30-1-2003"));
 
 {{index destructuring, "underscore character"}}
 
-The `_` (underscore) binding is ignored, and only used to skip the
+The `_` (underscore) binding is ignored, and used only to skip the
 full match element in the array returned by `exec`.
 
 ## Word and string boundaries
@@ -918,7 +918,7 @@ found, `lastIndex` is set back to zero, which is also the value it has
 in a newly constructed regular expression object.
 
 The difference between the global and the sticky options is that, when
-sticky is enabled, the match will only succeed if it starts directly
+sticky is enabled, the match will succeed only if it starts directly
 at `lastIndex`, whereas with global, it will search ahead for a
 position where a match can start.
 
@@ -1352,7 +1352,7 @@ if}}
 
 {{index "quoting style (exercise)", boundary}}
 
-The most obvious solution is to only replace quotes with a nonword
+The most obvious solution is to replace only quotes with a nonword
 character on at least one side. Something like `/\W'|'\W/`. But you
 also have to take the start and end of the line into account.
 
diff --git a/10_modules.md b/10_modules.md
@@ -21,7 +21,7 @@ easy to explain, and each part plays a well-defined role.
 
 A typical real program grows organically. New pieces of functionality
 are added as new needs come up. Structuring—and preserving
-structure—is additional work, work which will only pay off in the
+structure—is additional work, work which will pay off only in the
 future, the _next_ time someone works on the program. So it is
 tempting to neglect it, and allow the parts of the program to become
 deeply entangled.
@@ -160,7 +160,7 @@ found problems in the code, or who want to propose new features, is
 even more work.
 
 By default, you own the ((copyright)) to the code you write, and other
-people may only use it with your permission. But because some people
+people may use it only with your permission. But because some people
 are just nice, and because publishing good software can help make you
 a little bit famous among programmers, many packages are published
 under a ((license)) that explicitly allows other people to use it.
diff --git a/11_async.md b/11_async.md
@@ -37,8 +37,8 @@ progress while it is waiting for a network request.
 {{index "synchronous programming"}}
 
 In a _synchronous_ programming model, things happen one at a time.
-When you call a function that performs a long-running action, it only
-returns when the action has finished and it can return the result.
+When you call a function that performs a long-running action, it
+returns only when the action has finished and it can return the result.
 This stops your program for the time the action takes.
 
 {{index "asynchronous programming"}}
@@ -54,7 +54,7 @@ then combines results.
 
 {{index "synchronous programming"}}
 
-In a synchronous environment, where the request function only returns
+In a synchronous environment, where the request function returns only
 after it has done its work, the easiest way to perform this task is to
 make the requests one after the other. This has the drawback that the
 second request will be started only when the first has finished. The
@@ -378,7 +378,7 @@ functions they call, are caught and given to the right function.
 
 Promises make this easier. They can be either resolved (the action
 finished successfully) or rejected (it failed). Resolve handlers (as
-registered with `then`) are only called when the action is successful,
+registered with `then`) are called only when the action is successful,
 and rejections are automatically propagated to the new promise that is
 returned by `then`. And when a handler throws an exception, this
 automatically causes the promise produced by its `then` call to be
@@ -500,7 +500,7 @@ function request(nest, target, type, content) {
 
 {{index "Promise class", "resolving (a promise)", "rejecting (a promise)"}}
 
-Because promises can only be resolved (or rejected) once, this will
+Because promises can be resolved (or rejected) only once, this will
 work. The first time `resolve` or `reject` is called determines the
 outcome of the promise, and any further calls, such as the timeout
 arriving after the request finishes, or a request coming back after
@@ -617,7 +617,7 @@ of the current element as a second argument to its filtering function
 
 ## Network flooding
 
-The fact that nests can only talk to their neighbors greatly inhibits
+The fact that nests can talk only to their neighbors greatly inhibits
 the usefulness of this network.
 
 For broadcasting information to the whole network, one solution is to
@@ -700,7 +700,7 @@ send a request in the direction of a faraway nest, it is necessary to
 know which neighboring nest gets it closer to its destination. Sending
 it in the wrong direction will not do much good.
 
-Since each nest only knows about its direct neighbors, it doesn't have
+Since each nest knows about only its direct neighbors, it doesn't have
 the information it needs to compute a route. We must somehow spread
 the information about these connections to all nests. Preferably in a
 way that allows it to change over time, when nests are abandoned or
@@ -744,7 +744,7 @@ everywhere(nest => {
 {{index JSON, "== operator"}}
 
 The comparison uses `JSON.stringify` because `==`, on objects or
-arrays, will only return true when the two are the exact same value,
+arrays, will return true only when the two are the exact same value,
 which is not what we need here. Comparing the JSON strings is a crude
 but effective way to compare their content.
 
@@ -1080,7 +1080,7 @@ try {
 {{index thread, queue}}
 
 No matter how closely together events—such as timeouts or incoming
-requests—happen, a JavaScript environment will only run one program at
+requests—happen, a JavaScript environment will run only one program at
 a time. You can think of this as it running a big loop _around_ your
 program, called the _event loop_. When there's nothing to be done,
 that loop is stopped. But as events come in, they are added to a queue,
diff --git a/14_dom.md b/14_dom.md
@@ -200,7 +200,7 @@ child, `nextSibling` will be null.
 
 {{index "children property", "text node", element}}
 
-There's also the `children` property, which is like `childNodes` but
+There's also the `children` property, which is like `childNodes`, but
 contains only element (type 1) children, not other types of
 child nodes. This can be useful when you aren't interested in text
 nodes.
diff --git a/15_event.md b/15_event.md
@@ -67,8 +67,8 @@ argument occurs.
 Each ((browser)) event handler is registered in a context. In the last example we called
 `addEventListener` on the `window` object to register a handler
 for the whole window. Such a method can also be found on ((DOM))
-elements and some other types of objects. Event listeners are only
-called when the event happens in the context of the object they are
+elements and some other types of objects. Event listeners are
+called only when the event happens in the context of the object they are
 registered on.
 
 ```{lang: "text/html"}
@@ -744,7 +744,7 @@ browser event handlers behave like other asynchronous notifications.
 They are scheduled when the event occurs, but must wait for other
 scripts that are running to finish before they get a chance to run.
 
-The fact that events can only be processed when nothing else is
+The fact that events can be processed only when nothing else is
 running means that, if the event loop is tied up with other work, any
 interaction with the page (which happens through events) will be
 delayed until there's time to process it. So if you schedule too much
@@ -1134,7 +1134,7 @@ access to them. To implement the styling of the buttons, you could
 store objects that contain both tab panel and its button.
 
 I recommend writing a separate function for changing tabs. You can
-either store the previously selected tab, and only change the styles
+either store the previously selected tab, and change only the styles
 needed to hide that and show the new one, or you can just update the
 style of all tabs every time a new tab is selected.
 
diff --git a/17_canvas.md b/17_canvas.md
@@ -1179,8 +1179,8 @@ pixel surface gives canvas a lower cost per shape.
 
 There are also effects, such as rendering a scene one pixel at a time
 (for example using a ray tracer) or postprocessing an image with
-JavaScript (blurring or distorting it), that can only be realistically
-handled by a ((pixel))-based approach.
+JavaScript (blurring or distorting it), that can be realistically
+handled only by a ((pixel))-based approach.
 
 In some cases, you may want to combine several of these techniques.
 For example, you might draw a ((graph)) with ((SVG)) or ((canvas)) but
diff --git a/18_http.md b/18_http.md
@@ -334,7 +334,7 @@ of saying "I can't do that".
 
 To add a request body, you can include a `body` option. To set
 headers, there's the `headers` option. For example, this request
-includes a `Range` header, which instructs the server to only return a
+includes a `Range` header, which instructs the server to return only
 part of a response.
 
 ```{test: no}
@@ -581,7 +581,7 @@ the currently active element and the recipient of keyboard ((input)).
 
 {{index "option (HTML tag)", "select (HTML tag)"}}
 
-Thus you can only type into a ((text field)) when it is focused. Other
+Thus you can type into a ((text field)) only when it is focused. Other
 fields respond differently to keyboard events. For example, a
 `<select>` menu tries to move to the option that contains the text the
 user typed and responds to the arrow keys by moving its selection up
@@ -1087,7 +1087,7 @@ removed with `removeItem`, or the user clears their local data.
 
 Sites from different ((domain))s get different storage
 compartments. That means data stored in `localStorage` by a given
-website can, in principle, only be read (and overwritten) by scripts on
+website can, in principle, be read (and overwritten) only by scripts on
 that same site.
 
 {{index "localStorage object"}}
@@ -1155,7 +1155,7 @@ Notes: <select></select> <button>Add</button><br>
 
 The script gets its starting state from the `"Notes"` value stored in
 `localStorage` or, if that is missing, it creates an example state
-that only has a shopping list in it. Reading a field that does not
+that has only a shopping list in it. Reading a field that does not
 exist from `localStorage` will yield `null`. Passing `null` to
 `JSON.parse` will make it parse the string `"null"` and return `null`.
 Thus, the `||` operator can be used to provide a default value in a
diff --git a/19_paint.md b/19_paint.md
diff --git a/20_node.md b/20_node.md
diff --git a/21_skillsharing.md b/21_skillsharing.md
