spessoplayer 0.7.6-beta → 0.7.8-beta

package/audioBuffer.mjs

@@ -51,6 +51,9 @@ function writeLittleEndianIndexed(dataArray, number, byteTarget) {
     dataArray[dataArray.currentIndex++] = number >> i * 8 & 255;
   }
 }
+function writeDword(dataArray, dword) {
+  writeLittleEndianIndexed(dataArray, dword, 4);
+}
 function writeRIFFChunkParts(header, chunks, isList = false) {
   let dataOffset = 8;
   let headerWritten = header;
@@ -113,7 +116,7 @@ function writeRIFFChunkRaw(header, data, addZeroByte = false, isList = false) {
  * @param {Number} audioData.length - Audio length in samples, essentially the sample count
  * @param {Number} audioData.numChannels - How many channels the audio has
  * @param {Number} sampleRate - Sample rate of the audio
- * @param {Object} options - Optional, adds loop timestamps and more
+ * @param {Object} [options=DEFAULT_WAV_WRITE_OPTIONS] - Optional, adds loop timestamps and more
  * @returns {Uint8Array} the wav header
  */
 function getWavHeader({ length, numChannels }, sampleRate, options = DEFAULT_WAV_WRITE_OPTIONS) {

package/cli.mjs

@@ -22,6 +22,16 @@
 import { join, basename, parse } from "path"
 import { log, Options } from "./utils/utils.mjs"
 
+/** @type {(Promise<String[]>|String[])} */
+let argvWithoutFileExts = new Promise(resolve => {
+  const newArguments = [...new Set(process.argv.slice(2)).values()],
+        newArgumentsLength = newArguments.length;
+  for (let i = 0; i < newArgumentsLength; i++) {
+    const parsedElement = parse(newArguments[i]);
+    newArguments[i] = join(parsedElement.dir, parsedElement.name);
+  }
+  resolve(newArguments)
+});
 const regexes = {
   help: /^(?:--help|\/help|-h|\/h|\/\?)$/,
   version: /^(?:--version|\/version|-V|\/V)$/,
@@ -121,6 +131,11 @@ const testFunctions = {
   logFile: i => regexes.logFile.test(i)
 };
 
+/**
+ * Retrieves the first 20 bytes of a file
+ * @param {String} path path of file
+ * @return {Promise<String>} - first 20 bytes of file
+ */
 async function get20BytesFromFile(path) {
   let fileMagicNumber;
   await new Promise(resolve => {
@@ -136,15 +151,21 @@ async function get20BytesFromFile(path) {
   })
   return fileMagicNumber;
 }
+const setFilePromises = [];
 /**
  * Sets necessary variables in Options class for main.mjs
- * @param {Array} args - The process.argv to analyse
+ * @param {String[]} args - The process.argv to analyse
  * @throws {ReferenceError} - if the next argument doesn't exist
  */
 const actUpOnPassedArgs = async (args) => {
   let lastParam,
       lastIndex;
   let newArguments = args.slice(2);
+  const newArgumentsSet = new Set(newArguments),
+        noDuplicates = [...newArgumentsSet.values()],
+        /** @type {Map<String, (String|Symbol)>} */
+        doneFileList = new Map(newArgumentsSet.entries()),
+        doneSymbol = Symbol("ALREADY_DONE");
   if (newArguments.length === 0) {
     await help()
     process.exit()
@@ -198,8 +219,12 @@ const actUpOnPassedArgs = async (args) => {
     log(1, performance.now().toFixed(2), `Using variable DEBUG_FILE_SPESSO=${process.env["DEBUG_FILE_SPESSO"]}`)
   }
 
-  const setFilePromises = [],
-        effectsStdoutFunctions = [];
+  function clearLastVariables() {
+    lastParam = undefined,
+    lastIndex = undefined;
+  }
+  let indexOfSetFile = 0,
+      lastAutomaticFile;
   for (const arg of newArguments) {
     switch (arg) {
       case regexes.wav.test(arg) && arg: {
@@ -309,13 +334,25 @@ const actUpOnPassedArgs = async (args) => {
       case (lastParam === "input" || lastParam === undefined)
             && regexes.fileCheck.test(basename(arg))
             && arg: {
+        if (doneFileList.get(arg) === doneSymbol) {
+          if (lastParam === "input") clearLastVariables()
+          break;
+        }
+        doneFileList.set(arg, doneSymbol)
+        
+        if (!global.fs) {
+          const fs = await import("node:fs");
+          global.fs = fs;
+        }
         setFilePromises.push(
           setFile({
-            lastParam, lastIndex,
-            newArguments, arg
+            indexOfSetFile: indexOfSetFile++,
+            lastParam, lastIndex, lastAutomaticFile,
+            newArguments: noDuplicates, arg
           })
         )
-        if (lastParam === "input") lastParam = undefined;
+        if (!lastParam) lastAutomaticFile = arg;
+        if (lastParam === "input") clearLastVariables()
         break;
       }
       
@@ -323,35 +360,35 @@ const actUpOnPassedArgs = async (args) => {
         switch (lastParam) {
           case "loop":
             setLoop(arg, lastIndex)
-            lastParam = undefined;
+            clearLastVariables()
             break;
           case "loop-start":
             setLoopStart(arg, lastIndex)
-            lastParam = undefined;
+            clearLastVariables()
             break;
           case "loop-end":
             setLoopEnd(arg, lastIndex)
-            lastParam = undefined;
+            clearLastVariables()
             break;
           case "sample-rate":
             setSampleRate(arg, lastIndex, newArguments)
-            lastParam = undefined;
+            clearLastVariables()
             break;
           case "format":
-            setFormat(arg, lastIndex)
-            lastParam = undefined;
+            setFormat(arg)
+            clearLastVariables()
             break;
           case "volume":
             setVolume(arg, lastIndex)
-            lastParam = undefined;
+            clearLastVariables()
             break;
           case "reverb":
-            effectsStdoutFunctions.push(getReverb(arg, lastIndex))
-            lastParam = undefined;
+            setReverb(arg, lastIndex)
+            clearLastVariables()
             break;
           case "effects":
-            effectsStdoutFunctions.push(getEffects(arg, lastIndex))
-            lastParam = undefined;
+            setEffects(arg, lastIndex)
+            clearLastVariables()
             break;
           
           default:
@@ -366,17 +403,21 @@ const actUpOnPassedArgs = async (args) => {
         }
     }
   }
-  // Needs to be done here because otherwise the functions
-  // wouldn't always know if it's stdout mode
-  if (effectsStdoutFunctions.length > 0) {
-    const isStdout = Options.all.toStdout,
-          setFunction = i => i(isStdout);
-    effectsStdoutFunctions.forEach(setFunction)
-  }
-  // Adds files to the list asynchronously/in parallel
-  await Promise.all(setFilePromises)
-  if (!Options.all.files
-      || !Object.keys(Options.all.files).length > 0) {
+  /*
+    Adds files to the list asynchronously/in parallel
+    by chaining each function to the previous one
+    so that they stay syncronized and up to date.
+    
+    This means there's no performance loss because of
+    the async nature of them and it remains in
+    a sequential order regardless of execution timings.
+    
+    (e.g. sort order is the same like in process.argv
+     because each returned Promise waits before
+     actually adding the file)
+  */
+  await Promise.all(await Promise.all(setFilePromises))
+  if (!Object.keys(Options.all.files ?? []).length) {
     console.error(`${red}Missing required files${normal}`);
     process.exit(1)
   }
@@ -385,163 +426,165 @@ const actUpOnPassedArgs = async (args) => {
 /**
  * Sets a supported file inside a group in Options class
  * @param {Object} passedVariables - variables injected with this object
+ * @param {Number} passedVariables.indexOfSetFile - index of the current function inside setFilePromises
  * @param {String} passedVariables.lastParam - last parameter that has been used last time
- * @param {String} passedVariables.lastIndex - last index that has been set last time
- * @param {String} passedVariables.newArguments - arguments passed from the terminal
+ * @param {Object} passedVariables.lastIndex - last index object
+ * @param {String} [passedVariables.lastIndex.index] - last index that has been set last time
+ * @param {String} passedVariables.lastAutomaticFile - last file that has been set automatically
+ * @param {String[]} passedVariables.newArguments - arguments passed from the terminal
  * @param {String} passedVariables.arg - argument passed to this function that is also a file path
- * @return {(true|false)}
- *         true if it needs to break,
- *         false if it needs to fallthrough the switch
- *         (See "case regexes.fileCheck.test(basename(arg)) && arg")
+ * @return {Promise<Promise|undefined>}
  */
 const setFile = async ({
-  lastParam, lastIndex,
+  indexOfSetFile,
+  lastParam, lastIndex, lastAutomaticFile,
   newArguments, arg
 }) => {
-  function doesSetHave(setOfFiles, path, isMidi = true) {
+  /**
+   * Checks for the same basename as the path given inside process.argv
+   * @param {String} path - full file path to compare with another one
+   * @inner
+   * @private
+   * @memberof module:cli
+   * @return {Boolean} - whether or not it has found a similar file inside process.argv
+   */
+  function checkForIdenticalName(path) {
+    const indexOfPath = newArguments.indexOf(path);
     const pathUpToName = join(parse(path).dir, parse(path).name);
-    if (isMidi) {
-      return setOfFiles?.has(pathUpToName+".sf2")
-             || setOfFiles?.has(pathUpToName+".dls");
-    }
-    return setOfFiles?.has(pathUpToName+".mid");
-  }
-  function checkForIdenticalNames(path, isMidi = true) {
-    const pathUpToName = join(parse(path).dir, parse(path).name);
-    if (isMidi) {
-      return newArguments.includes(pathUpToName+".sf2")
-             || newArguments.includes(pathUpToName+".dls");
-    }
-    return newArguments.includes(pathUpToName+".mid");
-  }
-  if (lastParam !== undefined && lastParam !== "input") return false;
+    const noExtNewArguments = [...argvWithoutFileExts];
+    
+    delete noExtNewArguments[indexOfPath]
+    return noExtNewArguments.includes(pathUpToName);
+  }
+  /**
+   * Returns either a new Promise or attaches a .then Promise to an older one
+   * @param {Function} func function to run within a Promise
+   * @inner
+   * @private
+   * @memberof module:cli
+   * @return {(Promise|undefined)} - a new Promise that'll fulfill when the given function returns
+   */
+  function createPromise(func) {
+    const lastSetFilePromise = setFilePromises[indexOfSetFile-1];
+    return (!lastSetFilePromise)
+              ? func()
+              : lastSetFilePromise.then(() => func());
+  }
+  if (lastParam !== undefined && lastParam !== "input") return;
   
-  if (!global.fs) {
-    const fs = await import("node:fs");
-    global.fs = fs;
-  }
   const fileMagicNumber = await get20BytesFromFile(arg);
-  
-  // -- MIDI files --
-  if (fileMagicNumber.includes("MThd")) {
-    const inputIndex = Number(lastIndex?.index ?? 0);
-    const indexesAndKeys = (Options.all.files ?? [[]]).map((e, i) => [i, e]);
-    for (const infos of indexesAndKeys) {
-      let index, setOfFiles;
-      if (infos) {
-        [index, setOfFiles] = infos;
-      } else continue;
-      
-      if (setOfFiles instanceof Set
-          && doesSetHave(setOfFiles, arg)
-          && !lastIndex?.index && !lastParam) {
-        Options.files(index, arg);
-        log(1, performance.now().toFixed(2), `Set midi file to "${arg}" at index ${index}`)
-        return true;
-      }
-    }
-    for (const infos of indexesAndKeys) {
-      let index, setOfFiles;
-      if (infos) {
-        [index, setOfFiles] = infos;
-      } else continue;
-      
-      if (index === indexesAndKeys.length-1
-          && inputIndex !== index) {
-        if (checkForIdenticalNames(arg)
-            && !lastIndex?.index && !lastParam) {
-          Options.files(indexesAndKeys.length, arg)
-          log(1, performance.now().toFixed(2), `Set midi file to "${arg}" at index ${indexesAndKeys.length}`)
-          return true;
-        }
-        Options.files(inputIndex, arg)
-        log(1, performance.now().toFixed(2), `Set midi file to "${arg}" at index ${inputIndex}`)
-        return true;
-      }
-      if (index !== inputIndex) continue;
-      
-      if (checkForIdenticalNames(arg)
-          && !lastIndex?.index && !lastParam) {
-        Options.files(indexesAndKeys.length, arg)
-        log(1, performance.now().toFixed(2), `Set midi file to "${arg}" at index ${indexesAndKeys.length}`)
-        return true;
-      }
-      Options.files(index, arg);
-      log(1, performance.now().toFixed(2), `Set midi file to "${arg}" at index ${index}`)
-      return true;
-    }
+  let typeOfFile;
+  switch (true) {
+    case fileMagicNumber.includes("MThd"):
+      typeOfFile = true;
+      break;
+    case fileMagicNumber.includes("sfbk"):
+    case fileMagicNumber.includes("DLS"):
+      typeOfFile = false;
+      break;
+
+    default:
+      // Incompatible file
+      return;
   }
-  // -- End of MIDI files --
 
-  // Soundfont and downloadable sounds files
-  if (fileMagicNumber.includes("sfbk")
-      || fileMagicNumber.includes("DLS")) {
-    const inputIndex = Number(lastIndex?.index ?? 0);
-    const indexesAndKeys = (Options.all.files ?? [[]]).map((e, i) => [i, e]);
-    for (const infos of indexesAndKeys) {
-      let index, setOfFiles;
-      if (infos) {
-        [index, setOfFiles] = infos;
-      } else continue;
-      
-      if (setOfFiles instanceof Set
-          && doesSetHave(setOfFiles, arg, false)
-          && !lastIndex?.index && !lastParam) {
-        Options.files(index, arg, true);
-        log(1, performance.now().toFixed(2), `Set soundfont file to "${arg}" at index ${index}`)
-        return true;
-      }
+  const inputIndex = Number(lastIndex?.index ?? 0);
+  const logMessages = {
+    getMessage(type, arg, index) {
+      return (type)
+        ? `Set midi file to "${arg}" at index ${index}`
+        : `Set soundfont file to "${arg}" at index ${index}`;
+    },
+    getReplacedSoundfont(original, newOne, index) {
+      return `Replaced soundfont file from "${original}" to "${newOne}" at index ${index}`;
     }
-    for (const infos of indexesAndKeys) {
-      let index, setOfFiles;
-      if (infos) {
-        [index, setOfFiles] = infos;
-      } else continue;
-      
-      if (index === indexesAndKeys.length-1
-          && index !== inputIndex) {
-        if (checkForIdenticalNames(arg, false)
-            && !lastIndex?.index && !lastParam) {
-          Options.files(indexesAndKeys.length, arg, true)
-          log(1, performance.now().toFixed(2), `Set soundfont file to "${arg}" at index ${indexesAndKeys.length}`)
-          return true;
-        }
-        Options.files(inputIndex, arg, true);
-        log(1, performance.now().toFixed(2), `Set soundfont file to "${arg}" at index ${inputIndex}`)
-        return true;
+  };
+  if (lastIndex?.index || lastParam) {
+    return createPromise(async () => {
+      let needsToBeReplaced = false;
+
+      // Replaces the last soundfont it can reach if it needs to
+      if (!typeOfFile) {
+        const setOfFiles = Options.all.files[inputIndex];
+        const fileMagicNumber = (setOfFiles instanceof Set)
+          ? await get20BytesFromFile(setOfFiles.getIndex(0))
+          : [];
+        if (fileMagicNumber.includes("sfbk")
+            || fileMagicNumber.includes("DLS")) needsToBeReplaced = true;
       }
-      if (index !== inputIndex) continue;
+      Options.files(inputIndex, arg, !typeOfFile, needsToBeReplaced)
+      log(1,
+        performance.now().toFixed(2),
+        logMessages.getMessage(typeOfFile, arg, inputIndex)
+      )
+    });
+  }
+  
+  // --- Automatic addition of files section ---
+  return createPromise(async () => {
+    /* 
+      ⏳ if one group inside Options.all
+         has the same basename as arg,
+         then it adds arg to that group
+      ❌ Otherwise it runs the next check below it
+      (e.g. index 2 and he needs to add to that,
+       that's why it's seperated otherwise it creates
+       a new Set when it already exists)
+    */
+    const pathUpToName = join(parse(arg).dir, parse(arg).name);
+    const foundIndex = Options.searchAddedFile(pathUpToName, typeOfFile);
+    if (typeof foundIndex === "number") {
+      Options.files(foundIndex, arg, !typeOfFile);
+      log(1,
+        performance.now().toFixed(2),
+        logMessages.getMessage(typeOfFile, arg, foundIndex)
+      )
+      return;
+    }
+    if (argvWithoutFileExts instanceof Promise) argvWithoutFileExts = await argvWithoutFileExts;
+    // Creates new Sets for identical basename files
+    if (checkForIdenticalName(arg)) {
+      const amountOfGroups = Options.amountOfGroups;
+      Options.files(amountOfGroups, arg, !typeOfFile)
+      log(1,
+        performance.now().toFixed(2),
+        logMessages.getMessage(typeOfFile, arg, amountOfGroups)
+      )
+      return;
+    }
+    // It just adds to the last Set it can reach
+    let lastKnownGroupIndex = Options.lastKnownGroupIndex ?? 0;
+    // or maybe to the last automatic group
+    // if a file has been added automatically last time
+    if (lastAutomaticFile) automaticFileCheck: {
+      const pathUpToName = join(parse(lastAutomaticFile).dir, parse(lastAutomaticFile).name);
+      const indexOfGroup = Options.searchAddedFile(pathUpToName);
+      if (typeof indexOfGroup !== "number") break automaticFileCheck;
       
-      if (checkForIdenticalNames(arg, false)
-          && !lastIndex?.index && !lastParam) {
-        Options.files(indexesAndKeys.length, arg, true)
-        log(1, performance.now().toFixed(2), `Set soundfont file to "${arg}" at index ${indexesAndKeys.length}`)
-        return true;
-      }
-      const fileMagicNumber = (setOfFiles instanceof Set)
-        ? await get20BytesFromFile(setOfFiles.getIndex(0))
-        : [];
-      if (fileMagicNumber.includes("sfbk")
-          || fileMagicNumber.includes("DLS")) {
-        log(1, performance.now().toFixed(2), `Replaced soundfont file from "${setOfFiles.getIndex(0)}" to "${arg}" at index ${index}`)
-        Options.files(index, arg, true, true);
-        return true;
+      if (Options.isAutomaticBasenameGroup(argvWithoutFileExts, indexOfGroup)) {
+        lastKnownGroupIndex++
+      } else {
+        lastKnownGroupIndex = indexOfGroup;
       }
-      Options.files(index, arg, true);
-      log(1, performance.now().toFixed(2), `Set soundfont file to "${arg}" at index ${index}`)
-      return true;
     }
-  }
-  // End of soundfont and downloadable sounds files
+    Options.files(lastKnownGroupIndex, arg, !typeOfFile);
+    log(1,
+      performance.now().toFixed(2),
+      logMessages.getMessage(typeOfFile, arg, lastKnownGroupIndex)
+    )
+  });
+  // --- END of automatic addition of files section ---
 }
 /**
- * Sets the Options.loopN variable
+ * Sets the Options.loopAmount variable
  * @param {String} arg - the loop amount
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
 const setLoop = (arg, lastIndex) => {
   if (typeof Number(arg) === "number"
       && !regexes.infinity.test(arg)) {
-    Options.loopN(Number(lastIndex?.index), Number(arg));
+    Options.loopAmount(Number(lastIndex?.index), Number(arg));
     log(1, performance.now().toFixed(2), `Set loop amount to ${Number(arg)} at ${lastIndex?.index} index`)
     return;
   }
@@ -555,6 +598,8 @@ const setLoop = (arg, lastIndex) => {
 /**
  * Sets the Options.loopStart variable
  * @param {String} arg - the start of the loop in seconds or in HH:MM:SS:ms format
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
 const setLoopStart = (arg, lastIndex) => {
   if (typeof Number(arg) === "number"
@@ -575,6 +620,8 @@ const setLoopStart = (arg, lastIndex) => {
 /**
  * Sets the Options.loopEnd variable
  * @param {String} arg - the end of the loop in seconds or in HH:MM:SS:ms format
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
 const setLoopEnd = (arg, lastIndex) => {
   if (typeof Number(arg) === "number"
@@ -595,6 +642,9 @@ const setLoopEnd = (arg, lastIndex) => {
 /**
  * Sets the Options.sampleRate variable
  * @param {String} arg - the sample rate to set
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
+ * @param {String[]} newArguments - process.argv without 2 starting indexes
  */
 const setSampleRate = (arg, lastIndex, newArguments) => {
   if (typeof Number(arg) === "number" && !arg.startsWith("-")) {
@@ -612,7 +662,7 @@ const setSampleRate = (arg, lastIndex, newArguments) => {
 }
 /**
  * Simply changes how the program should log
- * @param {Number} arg - the level of how much it should log
+ * @param {String} arg - the level of how much it should log
  */
 const setVerboseLevel = async (arg) => {
   const isFromUser = arg !== undefined;
@@ -661,11 +711,12 @@ const setFormat = arg => {
   process.exit(1);
 }
 /**
- * Gives a function that will apply effects from the user's string passed through --effects
+ * Applies effects from the user's string passed through --effects
  * @param {String} arg - the comma-separeted string to parse
- * @return {Function} - a function that will set the effects parameter
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
-const getEffects = (arg, lastIndex) => {
+const setEffects = (arg, lastIndex) => {
   const regexListOfEffects = (
     "allpass|band|bandpass|bandreject|bass|bend|biquad" +
     "|chorus|channels|compand|contrast|dcshift|deemph|delay" +
@@ -707,14 +758,9 @@ const getEffects = (arg, lastIndex) => {
       process.exit(1);
     }
     
-    return isStdout => {
-      if (isStdout) {
-        Options.effectsStdout = list;
-      } else {
-        Options.effects(Number(lastIndex?.index), list);
-      }
-      log(1, performance.now().toFixed(2), `Set list of SoX effects as ${list} at ${lastIndex?.index} index`)
-    };
+    Options.effects(Number(lastIndex?.index), list);
+    log(1, performance.now().toFixed(2), `Set list of SoX effects as ${global.effects}`)
+    return;
   }
   console.error(`${normalRed}The string for SoX effects you passed is not usable${normal}`);
   process.exit(1);
@@ -722,6 +768,8 @@ const getEffects = (arg, lastIndex) => {
 /**
  * Sets the Options.volume variable for the masterGain
  * @param {String} arg - the volume in either percentage, decibels or decimals
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
 const setVolume = (arg, lastIndex) => {
   if (regexes.areDecibels.test(arg)) {
@@ -746,41 +794,32 @@ const setVolume = (arg, lastIndex) => {
   process.exit(1);
 }
 /**
- * Gets the value for the reverb's volume for later use
+ * Sets the Options.reverb variable
  * @param {String} arg - the volume in either percentage, decibels or decimals
- * @param {Object} lastIndex - regex named group object
- * @return {Function} - function for setting/adding to Options.reverbVolume
+ * @param {Object} lastIndex - last index object
+ * @param {String} [lastIndex.index] - last index that has been set last time
  */
-const getReverb = (arg, lastIndex) => {
-  let valueToSet;
+const setReverb = (arg, lastIndex) => {
   if (regexes.areDecibels.test(arg)) {
     const dBNumber = Number(arg.match(regexes.decibelNumber)[1]);
-    valueToSet = dBNumber;
+    Options.reverbVolume(Number(lastIndex?.index), dBNumber);
+    Options.effects(Number(lastIndex?.index), []);
+    log(1, performance.now().toFixed(2), `Set reverb volume to ${Options.all.reverbVolume.find(i => i === dBNumber)} and effects variable to ${lastIndex?.index}`)
     return;
   }
   if (regexes.isPercentage.test(arg)) {
     const percentage = Number(arg.match(regexes.percentageNumber)[1]);
     const toDB = 10 * 10**(percentage/100);
-    valueToSet = toDB;
+    Options.reverbVolume(Number(lastIndex?.index), toDB);
+    Options.effects(Number(lastIndex?.index), []);
+    log(1, performance.now().toFixed(2), `Set reverb volume to ${Options.all.reverbVolume.find(i => i === toDB)} and effects variable to ${lastIndex?.index}`)
     return;
   }
   if (typeof Number(arg) === "number" && !arg.startsWith("-")) {
-    valueToSet = Number(arg);
-  }
-  
-  if (valueToSet) {
-    return isStdout => {
-      if (isStdout) {
-        Options.reverbVolumeStdout = valueToSet;
-      } else {
-        Options.reverbVolume(Number(lastIndex?.index), valueToSet)
-      }
-      Options.effects(Number(lastIndex?.index), [])
-      log(1,
-        performance.now().toFixed(2),
-        `Set reverb volume to ${valueToSet} at ${lastIndex?.index} index and effects variable to []`)
-      return;
-    };
+    Options.reverbVolume(Number(lastIndex?.index), Number(arg));
+    Options.effects(Number(lastIndex?.index), []);
+    log(1, performance.now().toFixed(2), `Set reverb volume to ${Options.all.reverbVolume.find(i => i === Number(arg))} and effects variable to ${lastIndex?.index}`)
+    return;
   }
   console.error(`${normalRed}Passed something that wasn't a valid number/dB/percentage${normal}`)
   process.exit(1);
@@ -790,7 +829,7 @@ const getReverb = (arg, lastIndex) => {
  * @param {String} arg - Path to the log file
  */
 const setLogFilePath = arg => {
-  Options.logFilePath(arg ?? "./spesso.log");
+  Options.logFilePath = arg ?? "./spesso.log";
   log(1, performance.now().toFixed(2), `Set log file path to ${arg ?? "./spesso.log"}`)
 }
 /**
@@ -816,8 +855,8 @@ const uninstall = async () => {
 }
 /**
  * Shows the help text
- * @param {Object} errorObject - an object containing additional info that should be printed alongside help
- * @param {String} errorObject.errorText - error text that should be printed before helpText
+ * @param {Object} [errorObject=""] - an object containing additional info that should be printed alongside help
+ * @param {String} [errorObject.errorText] - error text that should be printed before helpText
  */
 const help = async ({ errorText } = "") => {
   const optionalIndex = `${normal}[${dimGray}n${normal}]`;
@@ -890,10 +929,10 @@ const help = async ({ errorText } = "") => {
   `
   if (process.env.PAGER) {
     const { spawnSync } = await import("child_process");
-    const PAGERCommand = process.env.PAGER.split(" ").slice(0, 1),
+    const PAGERCommand = process.env.PAGER.split(" ").slice(0, 1)[0],
           PAGERArguments = process.env.PAGER.split(" ").slice(1);
     spawnSync(
-      ...PAGERCommand,
+      PAGERCommand,
       [...PAGERArguments],
       {
         stdio: ["pipe", "inherit", "inherit"],