Fix some inline CSS/span syntax

Author: cycomachead

03-building-a-block.md

@@ -40,10 +40,10 @@ all sprites, or only to the current sprite and its children.
 
 In this dialog box, you can choose the block's palette, shape, and name.
 With one exception, there is one color per
-palette, e.g., all {span .mono}[Motion] blocks are blue. But the {span .mono}[Variables] palette
+palette, e.g., all {span .mono}`Motion` blocks are blue. But the {span .mono}`Variables` palette
 includes the orange variable-related blocks and the red list-related
 blocks. Both colors are available, along with an "`Other`" option that
-makes grey blocks in the {span .mono}[Variables] palette for blocks that don’t fit any
+makes grey blocks in the {span .mono}`Variables` palette for blocks that don’t fit any
 category.
 
 There are three block shapes , following a
@@ -55,7 +55,7 @@ Predicates, which is the technical term for reporters that report
 Boolean (true or false) values.
 
 Suppose you want to make a block named “square” that draws a square. You
-would choose {span .mono}[Motion], Command, and type “square” into the name field.
+would choose {span .mono}`Motion`, Command, and type “square” into the name field.
 When you click "`OK`", you enter the {index}`Block Editor`.
 This works just like making a script in the sprite’s scripting area,
 except that the “hat” block at the top, instead of saying something like
@@ -68,7 +68,7 @@ custom block, then click OK:
 
 {img alt="image503.png" width="4.62in"}`images/03-building-a-block/image503.png`
 
-Your block appears at the bottom of the {span .mono}[Motion] palette. Here’s the block
+Your block appears at the bottom of the {span .mono}`Motion` palette. Here’s the block
 and the result of using it:
 
 {img alt="image524.png" width="4.20in"}`images/03-building-a-block/image524.png`
@@ -109,7 +109,7 @@ You can now drag the orange variable down into the script, then click okay:
 
 {img alt="image511.png" width="1.47in"}`images/03-building-a-block/image511.png`
 
-Your block now appears in the {span .mono}[Motion] palette with an input box: ![image512.png](images/03-building-a-block/image512.png) <!--  style="width:0.69792in;height:0.25in" / --> You can draw
+Your block now appears in the {span .mono}`Motion` palette with an input box: ![image512.png](images/03-building-a-block/image512.png) <!--  style="width:0.69792in;height:0.25in" / --> You can draw
 any size square by entering the length of its side in the box and
 running the block as usual, by clicking it or by putting it in a script.
 
@@ -236,11 +236,11 @@ The window shows all of your
 global custom blocks. You can uncheck some of the checkboxes to select
 exactly which blocks you want to include in your library. (You can
 "`right-click`" or "`control-click`" on the export window for a menu that lets
-you check or uncheck all the boxes at once.) Then press "`OK`" An {span .mono}[XML] file
+you check or uncheck all the boxes at once.) Then press "`OK`" An {span .mono}`XML` file
 containing the blocks will appear in your Downloads location.
 
 To import a block library, use the "`Import…`" command in the "`File`" menu,
-or just drag the {span .mono}[XML] file into the Snap<em>!</em> window.
+or just drag the {span .mono}`XML` file into the Snap<em>!</em> window.
 
 Several block libraries are included with Snap<em>!</em>; for details about
 them, see @sec-libraries.

05-typed-inputs.md

@@ -10,13 +10,13 @@ data type
 
 ## Scratch’s Type Notation
 
-Prior to version 3, Scratch block inputs came in two types: {span .mono}[Text-or-number] type and {span .mono}[Number] type. The former is
+Prior to version 3, Scratch block inputs came in two types: {span .mono}`Text-or-number` type and {span .mono}`Number` type. The former is
 indicated by a rectangular box, the latter by a rounded box: {inline alt="image654.png" class="image-inline"}`images/05-typed-inputs/image654.png`. A third
-Scratch type, {span .mono}[Boolean] (true/false), can be used in certain {span .mono}[Control]
+Scratch type, {span .mono}`Boolean` (true/false), can be used in certain {span .mono}`Control`
 blocks with hexagonal slots.
 
-The Snap<em>!</em> types are an expanded collection including {span .mono}[Procedure], {span .mono}[List],
-and {span .mono}[Object] types. Note that, with the exception of {span .mono}[Procedure] types, all
+The Snap<em>!</em> types are an expanded collection including {span .mono}`Procedure`, {span .mono}`List`,
+and {span .mono}`Object` types. Note that, with the exception of {span .mono}`Procedure` types, all
 of the input type shapes are just reminders to the user of what the
 block expects; they are not enforced by the language.
 
@@ -56,31 +56,31 @@ find the type you want.
 {img alt="image659.png" width="6.82in"}`images/05-typed-inputs/image659.png`
 
 The second row of input types
-contains the ones found in Scratch: {span .mono}[Number], {span .mono}[Any], and {span .mono}[Boolean]. (The
+contains the ones found in Scratch: {span .mono}`Number`, {span .mono}`Any`, and {span .mono}`Boolean`. (The
 reason these are in the second row rather than the first will become
 clear when we look at the column arrangement.) The first row contains the
-new Snap<em>!</em> types other than procedures: {span .mono}[Object], {span .mono}[Text], and {span .mono}[List]. The last two rows are the types related to procedures, discussed more fully below.
+new Snap<em>!</em> types other than procedures: {span .mono}`Object`, {span .mono}`Text`, and {span .mono}`List`. The last two rows are the types related to procedures, discussed more fully below.
 
-The {span .mono}[List] type is used for first class lists, discussed
+The {span .mono}`List` type is used for first class lists, discussed
 in Chapter IV. The red rectangles inside the input slot are meant
 to resemble the appearance of lists as Snap<em>!</em> displays them on the
 stage: each element in a red rectangle.
 
-The {span .mono}[Object] type is for sprites, costumes, sounds,
+The {span .mono}`Object` type is for sprites, costumes, sounds,
 and similar data types.
 
-The {span .mono}[Text] type is really just a variant form of the Any
+The {span .mono}`Text` type is really just a variant form of the Any
 type, using a shape that suggests a text input.[^5]
 
-[^5]: In Scratch, every block that takes a {span .mono}[Text-type] input has a default
+[^5]: In Scratch, every block that takes a {span .mono}`Text-type` input has a default
 value that makes the rectangles for text wider than tall. The blocks
-that aren’t specifically about text either are of {span .mono}[Number] type
+that aren’t specifically about text either are of {span .mono}`Number` type
 or have no default value, so those rectangles are
-taller than wide. At first some of us (bh) thought that {span .mono}[Text] was a
+taller than wide. At first some of us (bh) thought that {span .mono}`Text` was a
 separate type that always had a wide input slot; it turns out that this
 isn’t true in Scratch (delete the default text and the rectangle
 narrows), but we thought it a good idea anyway, so we allow Text-shaped
-boxes even for empty input slots. (This is why {span .mono}[Text] comes just above {span .mono}[Any]
+boxes even for empty input slots. (This is why {span .mono}`Text` comes just above {span .mono}`Any`
 in the input type selection box.)
 
 :::{index} jigsaw-piece blocks
@@ -139,8 +139,8 @@ in an arbitrary input instead of using the pulldown menu.
 
 Custom blocks can
 also have such inputs. To make a pulldown input, open the long form
-input dialog, choose a text type ({span .mono}[Any], {span .mono}[Text], or {span .mono}[Number]) and click the {inline alt="image658.png"}`images/05-typed-inputs/image658.png` <!--  style="width:0.13194in;height:0.13194in" -->
-icon in the bottom right corner, or {span .mono}[control/right-click] in the dialog.
+input dialog, choose a text type ({span .mono}`Any`, {span .mono}`Text`, or {span .mono}`Number`) and click the {inline alt="image658.png"}`images/05-typed-inputs/image658.png` <!--  style="width:0.13194in;height:0.13194in" -->
+icon in the bottom right corner, or {span .mono}`control/right-click` in the dialog.
 You will see this menu:
 
 Click
@@ -211,7 +211,7 @@ type array.
 
 The "`single input`" option: In Scratch, all inputs are in this category.
 There is one input slot in the block as it appears in its palette. If a
-single input is of type {span .mono}[Any], {span .mono}[Number], {span .mono}[Text], or {span .mono}[Boolean], then you can
+single input is of type {span .mono}`Any`, {span .mono}`Number`, {span .mono}`Text`, or {span .mono}`Boolean`, then you can
 specify a {index}`default value` that will be shown in that
 slot in the palette, like the “10” in the <code>move (10) steps block</code>. In the
 prototype block at the top of the script in the Block editor, an an input with
@@ -225,7 +225,7 @@ The "`Multiple inputs`" option:
 The <code>list</code> block introduced earlier accepts any number of inputs to
 specify the items of the new list. To allow this, Snap<em>!</em> introduces the
 arrowhead notation (⏴⏵) that expands and contracts the block, adding and
-removing input slots. ({span .mono}[Shift-clicking] on an arrowhead adds or removes
+removing input slots. ({span .mono}`Shift-clicking` on an arrowhead adds or removes
 three input slots at once.) Custom blocks made by the Snap<em>!</em> user have
 that capability, too. If you choose the "`Multiple inputs`" button, then
 arrowheads will appear after the input slot in the

06-procedures-as-data.md

@@ -91,7 +91,7 @@ and `map` above. This notation indicates that *the block itself,* not the
 number or other value that the block would report when called, is the
 input. If you want to use a block itself in a non-Reporter-type (e.g.,
 Any-type) input slot, you can enclose it explicitly in a ring, found at
-the top of the {span .mono}[Operators] palette.
+the top of the {span .mono}`Operators` palette.
 
 {img alt="image744.png" width="1.08in"}`images/06-procedures-as-data/image744.png`
 
@@ -152,10 +152,10 @@ otherwise, “reporter” includes predicates. When the word is capitalized
 inside a sentence, it means specifically oval-shaped blocks. So, “nested
 reporters” includes predicates, but “a Reporter-type input” doesn’t.)
 
-Although an {span .mono}[Any-type] input slot (what you get if you use the small
+Although an {span .mono}`Any-type` input slot (what you get if you use the small
 input-name dialog box) will accept a procedure input, it doesn’t
 automatically ring the input as described above. So the declaration of
-{span .mono}[Procedure-type] inputs makes the use of your custom higher order block
+{span .mono}`Procedure-type` inputs makes the use of your custom higher order block
 much more convenient.
 
 Why would you want a block to take a procedure as input? This is actually
@@ -173,7 +173,7 @@ the C when the block is used is the input named <var>action</var> in the body of
 the script. The only way to make sense of the variable <var>action</var> is to
 understand that its value is a script.
 
-To declare an input to be {span .mono}[Procedure-type], open the input name dialog as usual, and click on the arrowhead:
+To declare an input to be {span .mono}`Procedure-type`, open the input name dialog as usual, and click on the arrowhead:
 
 {img alt="image509.png" width="2.58in"}`images/06-procedures-as-data/image509.png`
 
@@ -355,7 +355,7 @@ stop Snap<em>!</em> from filling a slot that should really remain empty.
 
 Here’s
 an example of a situation in which a procedure must be explicitly marked
-as data by pulling a `ring` from the {span .mono}[Operators] palette and putting the
+as data by pulling a `ring` from the {span .mono}`Operators` palette and putting the
 procedure (block or script) inside it:
 
 {img alt="image734.png" width="5.19in"}`images/06-procedures-as-data/image734.png`
@@ -420,7 +420,7 @@ an infinite loop. We need `my if then else` block to be able to select
 only one of the two alternatives to be evaluated.
 
 We have a mechanism to allow that: declare the then variable <var>yes</var> and else variable <var>no</var> inputs to
-be of type {span .mono}[Reporter] rather than type {span .mono}[Any]. Then, when calling the block,
+be of type {span .mono}`Reporter` rather than type {span .mono}`Any`. Then, when calling the block,
 those inputs will be enclosed in a `ring` so that the expressions
 themselves, rather than their values, become the inputs:
 
@@ -458,16 +458,16 @@ transformation of constant data into constant functions) is called a
 *special form*. To turn our `if` block into a
 special form, we edit the block’s prototype, declaring the inputs <var>yes</var>
 and <var>no</var> to be of type "`Any (unevaluated)`"
-instead of type {span .mono}[Reporter]. The script for the block is still that of the
+instead of type {span .mono}`Reporter`. The script for the block is still that of the
 second version, including the use of `call` to evaluate either <var>yes</var> or <var>no</var>
-but not both. But the slots appear as white {span .mono}[Any-type] rectangles, not
-{span .mono}[Reporter-type] rings, and the factorial block will look like our first
+but not both. But the slots appear as white {span .mono}`Any-type` rectangles, not
+{span .mono}`Reporter-type` rings, and the factorial block will look like our first
 attempt.
 
 In a special form’s prototype, {index}`the unevaluated`
 input slot(s) are indicated by a lambda ("`λ`") next to the input name, just
-as if they were declared as {span .mono}[Procedure] type. They
-*are* {span .mono}[Procedure] type, really; they’re just disguised to the user of the
+as if they were declared as {span .mono}`Procedure` type. They
+*are* {span .mono}`Procedure` type, really; they’re just disguised to the user of the
 block.
 
 Special forms trade off implementor sophistication
@@ -494,14 +494,14 @@ Scratch doesn’t have custom C‑shaped blocks, it can afford to handwave
 away the distinction between evaluated and unevaluated Booleans, but
 Snap<em>!</em> can’t. The pedagogic value of special forms is proven by the
 fact that no Scratcher ever notices that there’s anything strange about
-the way in which the hexagonal inputs in the {span .mono}[Control] blocks are
+the way in which the hexagonal inputs in the {span .mono}`Control` blocks are
 evaluated.
 
 Also, the C-shaped slot familiar to Scratch users
 is an unevaluated procedure type; you don’t have to use a `ring` to keep
 the commands in the C-slot from being run before the C-shaped block is
 run. Those commands themselves, not the result of running them, are the
-input to the C-shaped {span .mono}[Control] block. (This is taken for granted by
+input to the C-shaped {span .mono}`Control` block. (This is taken for granted by
 Scratch users, especially because Scratchers don’t think of the contents
 of a C-slot as an input at all.) This is why it makes sense that
 “C‑shaped” is on the fourth row of types in the long form input dialog,