Rewrite part of evaluation logic, run prettier

src/documentation/basics/code.ts

@@ -22,7 +22,7 @@ The code you enter in any of the scripts is evaluated in strict mode. This tells
 	
 - **about variables:** the state of your variables is not kept between iterations. If you write <ic>let a = 2</ic> and remove that value from your script, **it will crash**! Variable and state is not preserved between each run of the script. There are other ways to deal with variables and to share variables between scripts! Some variables like **iterators** can keep their state between iterations because they are saved **with the file itself**. There is also **global variables**.
 - **about errors and printing:** your code will crash! Don't worry, we do our best to make it crash in the most gracious way possible. Most errors are caught and displayed in the interface. For weirder bugs, open the dev console with ${key_shortcut(
-    "Ctrl + Shift + I"
+    "Ctrl + Shift + I",
   )}. You cannot directly use <ic>console.log('hello, world')</ic> in the interface but you can use <ic>log(message)</ic> to print a one line message. You will have to open the console as well to see your messages being printed there!
 - **about new syntax:** sometimes, we had some fun with JavaScript's syntax in order to make it easier/faster to write on stage. <ic>&&</ic> can also be written <ic>::</ic> or <ic>-></ic> because it is faster to type or better for the eyes!
 	
@@ -31,8 +31,8 @@ The code you enter in any of the scripts is evaluated in strict mode. This tells
 There are some techniques to keep code short and tidy. Don't try to write the shortest possible code! Use shortcuts when it makes sense. Take a look at the following examples:
 
 ${makeExample(
-    "Shortening your if conditions",
-    `
+  "Shortening your if conditions",
+  `
 // The && symbol (overriden by :: in Topos) is very often used for conditions!
 beat(.75) :: snd('linnhats').n([1,4,5].beat()).out()
 beat(1) :: snd('bd').out()
@@ -42,42 +42,42 @@ beat(1) :: snd('bd').out()
 //// beat(1) :: snd('bd').out() 
 
 `,
-    true
-  )}
+  true,
+)}
 
 ${makeExample(
-    "More complex conditions using ?",
-    `
+  "More complex conditions using ?",
+  `
 // The ? symbol can be used to write a if/true/false condition
 beat(4) ? snd('kick').out() : beat(2) :: snd('snare').out()
 // (true) ? log('very true') : log('very false')
 `,
-    false
-  )}
+  false,
+)}
 
 
 ${makeExample(
-    "Using not and other short symbols",
-    `
+  "Using not and other short symbols",
+  `
 // The ! symbol can be used to reverse a condition
 beat(4) ? snd('kick').out() : beat(2) :: snd('snare').out()
 !beat(2) :: beat(0.5) :: snd('clap').out()
 `,
-    false
-  )}
+  false,
+)}
 
 # About crashes and bugs
 	
 Things will crash! It's part of the show! You will learn progressively to avoid mistakes and to write safer code. Do not hesitate to kill the page or to stop the transport if you feel overwhelmed by an algorithm blowing up. There is no safeguard to stop you from doing most things. This is to ensure that you have all the available possible room to write bespoke code and experiment with your ideas through code.
 
 ${makeExample(
-    "This example will crash! Who cares?",
-    `
+  "This example will crash! Who cares?",
+  `
 // This is crashing. See? No harm!
 qjldfqsdklqsjdlkqjsdlqkjdlksjd
 `,
-    true
-  )}
+  true,
+)}
 
 `;
 };

src/documentation/basics/interface.ts

@@ -18,44 +18,44 @@ The Topos interface is designed on a simple concept: _scripts_ and _universes_.
 Every Topos session is composed of **local**, **global** and **init** scripts. These scripts form a structure called a "_universe_".  The scripts can describe whatever you want: songs, sketches, small tools, or whatever. All the scripts are written using the JavaScript programming language. They describe a musical or algorithmic process. You can call them anytime.
 	
 - **the global script** (${key_shortcut(
-    "Ctrl + G"
+    "Ctrl + G",
   )}): _Evaluated for every clock pulse_. The central piece, acting as the conductor for all the other scripts. You can also jam directly from the global script to test your ideas before pushing them to a separate script. You can also access that script using the ${key_shortcut(
-    "F10"
+    "F10",
   )} key.
 - **the local scripts** (${key_shortcut(
-    "Ctrl + L"
+    "Ctrl + L",
   )}): _Evaluated on demand_. Local scripts are used to store anything too complex to sit in the global script. It can be a musical process, a whole section of your composition, a complex controller that you've built for your hardware, etc... You can also switch to one of the local scripts by using the function keys (${key_shortcut(
-    "F1"
+    "F1",
   )} to ${key_shortcut("F9")}).
 - **the init script** (${key_shortcut(
-    "Ctrl + I"
+    "Ctrl + I",
   )}): _Evaluated on program load_. Used to set up the software the session to the desired state before playing, for example changing bpm or to initialize global variables (See Functions). You can also access that script using the ${key_shortcut(
-    "F11"
+    "F11",
   )} key.
 - **the note file** (${key_shortcut(
-    "Ctrl + N"
+    "Ctrl + N",
   )}): _Not evaluated_. Used to store your thoughts or commentaries about the session you are currently playing. It is nothing more than a scratchpad really!
 	
 
 ${makeExample(
-    "Calling scripts to form a musical piece",
-    `
+  "Calling scripts to form a musical piece",
+  `
 beat(1) :: script(1) // Calling local script n°1 
 flip(4) :: beat(.5) :: script(2) // Calling script n°2
 `,
-    true
-  )}
+  true,
+)}
 
 ${makeExample(
-    "Script execution can become musical too!",
-    `
+  "Script execution can become musical too!",
+  `
 // Use algorithms to pick a script.
 beat(1) :: script([1, 3, 5].pick())
 flip(4) :: beat([.5, .25].beat(16)) :: script(
   [5, 6, 7, 8].beat())
 `,
-    false
-  )}
+  false,
+)}
 
 ### Navigating the interface
 
@@ -81,7 +81,7 @@ There are some useful functions to help you manage your scripts:
 
 
 A set of files is called a _universe_. You can switch between universes immediately immediately by pressing ${key_shortcut(
-    "Ctrl + B"
+    "Ctrl + B",
   )}. You can also create a new universe by entering a name. Load a universe by typing its name. Once a universe is loaded, it is not possible to call any data/code from any other universe. Switching between universes does not stop the transport nor reset the clock. The context switches but time keeps flowing. This can be useful for transitioning between songs / parts. 
 
 There are some useful functions to help you manage your universes:

src/documentation/basics/keyboard.ts

@@ -14,10 +14,10 @@ Topos is made to be controlled entirely with a keyboard. It is recommanded to st
 | Shortcut | Key   | Description                                                |
 |----------|-------|------------------------------------------------------------|
 |**Start/Pause** transport|${key_shortcut(
-    "Ctrl + P"
+    "Ctrl + P",
   )}|Start or pause audio playback|
 |**Stop** the transport |${key_shortcut(
-    "Ctrl + S"
+    "Ctrl + S",
   )}|Stop and rewind audio playback|
 	
 ### Moving in the interface
@@ -26,15 +26,15 @@ Topos is made to be controlled entirely with a keyboard. It is recommanded to st
 |----------|-------|------------------------------------------------------------|
 |Universe switch|${key_shortcut("Ctrl + B")}|Switch to a new universe|
 |Global Script|${key_shortcut("Ctrl + G")} or ${key_shortcut(
-    "F10"
+    "F10",
   )}|Switch to global script |
 |Local scripts|${key_shortcut("Ctrl + L")} or ${key_shortcut(
-    "F11"
+    "F11",
   )}|Switch to local scripts |
 |Init script|${key_shortcut("Ctrl + L")}|Switch to init script|
 |Note File|${key_shortcut("Ctrl + N")}|Switch to note file|
 |Local Script|${key_shortcut("F1")} to ${key_shortcut(
-    "F9"
+    "F9",
   )}|Switch to a specific local script|
 |Documentation|${key_shortcut("Ctrl + D")}|Open the documentation|
 	
@@ -44,10 +44,10 @@ Topos is made to be controlled entirely with a keyboard. It is recommanded to st
 |----------|-------|------------------------------------------------------------|
 |Evaluate|${key_shortcut("Ctrl + Enter")}| Evaluate the current script        |
 |Local Eval|${key_shortcut("Ctrl + F1")} to ${key_shortcut(
-    "Ctrl + F9"
+    "Ctrl + F9",
   )}|Local File Evaluation|
 |Force Eval|${key_shortcut(
-    "Ctrl + Shift + Enter"
+    "Ctrl + Shift + Enter",
   )}|Force evaluation of the current script|
 	
 ### Special
@@ -60,9 +60,9 @@ Topos is made to be controlled entirely with a keyboard. It is recommanded to st
 # Keyboard Fill
 
 By pressing the ${key_shortcut(
-    "Alt"
+    "Alt",
   )} key, you can trigger the <ic>Fill</ic> mode which can either be <ic>true</ic> or <ic>false</ic>. The fill will be set to <ic>true</ic> as long as the key is held. Try pressing ${key_shortcut(
-    "Alt"
+    "Alt",
   )} when playing this example:
 
 ${makeExample(
@@ -70,7 +70,7 @@ ${makeExample(
   `
 beat(fill() ? 1/4 : 1/2)::sound('cp').out()
 `,
-  true
+  true,
 )}
 
 `;

src/documentation/basics/mouse.ts

@@ -16,8 +16,8 @@ You can get the current position of the mouse on the screen by using the followi
 - <ic>mouseY()</ic>: the vertical position of the mouse on the screen (as a floating point number).
 	
 ${makeExample(
-    "Vibrato controlled by mouse",
-    `
+  "Vibrato controlled by mouse",
+  `
 beat(.25) :: sound('sine')
   .note([0,4,5,10,11,15,16]
         .palindrome()
@@ -27,8 +27,8 @@ beat(.25) :: sound('sine')
   .pan(r(0, 1))
   .room(0.35).size(4).out()
 `,
-    true
-  )}
+  true,
+)}
 
 <br>
 
@@ -39,15 +39,15 @@ Current mouse position can also be used to generate notes:
 	
 
 ${makeExample(
-    "Using the mouse to output a note!",
-    `
+  "Using the mouse to output a note!",
+  `
 beat(.25) :: sound('sine')
   .lpf(7000)
   .delay(0.5).delayt(1/6).delayfb(0.2)
   .note(noteX())
   .room(0.35).size(4).out()`,
-    true
-  )}
+  true,
+)}
 
 ## Mouse and Arrays
 
@@ -58,14 +58,14 @@ You can use the mouse to explore the valuesq contained in an Array:
 
 
 ${makeExample(
-    "Taking values out of an Array with the mouse",
-    `
+  "Taking values out of an Array with the mouse",
+  `
 log([1,2,3,4].mouseX())
 log([4,5,6,7].mouseY())
 
   `,
-    true
-  )}
+  true,
+)}
 
 
 

src/documentation/basics/welcome.ts

@@ -8,34 +8,34 @@ export const introduction = (application: Editor): string => {
 # Welcome
 	
 Welcome to the **Topos** documentation. You can jump here anytime by pressing ${key_shortcut(
-    "Ctrl + D"
+    "Ctrl + D",
   )}.  Press again to make the documentation disappear. Contributions are much appreciated! The documentation [lives here](https://github.com/Bubobubobubobubo/topos/tree/main/src/documentation).
 
 ${makeExample(
-    "Welcome! Eval to get started",
-    examples[Math.floor(Math.random() * examples.length)],
-    true
-  )}
+  "Welcome! Eval to get started",
+  examples[Math.floor(Math.random() * examples.length)],
+  true,
+)}
 	
 # What is Topos?
 	
 Topos is an _algorithmic_ sequencer. Topos is also a _live coding_ environment. To sum it up, think: "_making music in real time through code_". Code used as an expressive medium for musical improvisation! Topos uses small algorithms to represent musical sequences and processes.
 	
 ${makeExample(
-    "Small algorithms for direct musical expression",
-    `
+  "Small algorithms for direct musical expression",
+  `
 rhythm(.5, 4, 8) :: sound('drum').out()
 rhythm(.25, [5, 7].beat(2), 8) :: sound(['hc', 'fikea', 'hat'].pick(1))
   .lpf([500, 4000+usine(1/2)*2000]).pan(r(0, 1)).ad(0, [1, .5])
   .db(-ir(1,8)).speed([1,[0.5, 2].pick()]).room(0.5).size(3).o(4).out()
 beat([2,0.5].dur(13.5, 0.5))::snd('fsoftsnare')
   .n(0).speed([1, 0.5]).o(4).out()`,
-    false
-  )}
+  false,
+)}
 
 ${makeExample(
-    "Computer music should be immediate and intuitive",
-    `
+  "Computer music should be immediate and intuitive",
+  `
 let chord_prog = [0, 0, 5].bar() // Chord progression
 beat(.25)::snd('sine')
   .note(chord_prog + [60, 64, 67, 71].mouseX() 
@@ -47,26 +47,26 @@ beat(.25)::snd('sine')
   .delay(0.5).delayt(0.25).delayfb(0.7) // Delay
   .room(0.5).size(8) // Reverb
   .out()`,
-    false
-  )}
+  false,
+)}
 
 ${makeExample(
-    "Making the web less dreadful, one beep at at time",
-    `
+  "Making the web less dreadful, one beep at at time",
+  `
 beat(.5) :: sound('sid').n($(2))
   .room(1).speed([1,2].pick()).out()
 beat(.25) :: sound('sid').note(
   [34, 36, 41].beat(.25) + [[0,-24].pick(),12].beat())
   .room(0.9).size(0.9).n(4).out()`,
-    false
-  )}
+  false,
+)}
 	
 Topos is deeply inspired by the [Monome Teletype](https://monome.org/). The Teletype is/was an open source hardware module for Eurorack synthesizers. While the Teletype was initially born as an hardware module, Topos aims to be a web-browser based cousin of it! It is a sequencer, a scriptable interface, a companion for algorithmic music-making. Topos wishes to fullfill the same goal as the Teletype, keeping the same spirit alive on the web. It is free, open-source, and made to be shared and used by everyone.  Learn more about live coding on [livecoding.fr](https://livecoding.fr).
 
 ## Demo Songs
 
 Reloading the application will get you one random song example to study every time. Press ${key_shortcut(
-    "F5"
+    "F5",
   )} and listen to them all! The demo songs are also used a bit everywhere in the documentation to illustrate some of the working principles :).
 `;
 };